      def set_styles(self):
          """ Set global custom styles """
          gui_style = ttk.Style()
          gui_style.configure('TLabelframe.Label', foreground="#0046D5", relief=tk.SOLID)
  
      def build_gui(self, rebuild=False):
          """ Build the GUI """
          logger.debug("Building GUI")
          if not rebuild:
 
</s> remove     @staticmethod
    def set_styles():
 </s> add     def set_styles(self): </s> remove         gui_style.configure('Header.TLabel',
 </s> add         gui_style.configure('InfoHeader.TLabel', </s> remove         conf = dict()
        for section in self._config.config.sections():
            self._config.section = section
            category = section.split(".")[0]
            options = self._config.defaults[section]
            section = section.split(".")[-1]
            conf.setdefault(category, dict())[section] = OrderedDict()
            for key, val in options.items():
                if key == "helptext":
                    self._plugin_info[section] = val
                    continue
                initial_value = self._config.config_dict[key]
                initial_value = "none" if initial_value is None else initial_value
                conf[category][section][key] = ControlPanelOption(
                    title=key,
                    dtype=val["type"],
                    group=val["group"],
                    default=val["default"],
                    initial_value=initial_value,
                    choices=val["choices"],
                    is_radio=val["gui_radio"],
                    rounding=val["rounding"],
                    min_max=val["min_max"],
                    helptext=val["helptext"])
        logger.debug("Formatted Config for GUI: %s", conf)
        return conf

    def _build(self):
        """ Build the configuration pop-up window"""
        logger.debug("Building plugin config popup")
        container = ttk.Notebook(self._page_frame)
        categories = sorted(list(self._config_cpanel_dict.keys()))
        if "global" in categories:  # Move global to first item
            categories.insert(0, categories.pop(categories.index("global")))
        for category in categories:
            page = self._build_page(container, category)
            container.add(page, text=category.title())

        self._add_frame_separator()
        self._add_actions()

        container.pack(fill=tk.BOTH, expand=True)
        logger.debug("Built plugin config popup")

    def _build_page(self, container, category):
        """ Build a single tab within the plugin's configuration pop-up.
 </s> add         retval = dict()
        for plugin, conf in self._configs.items():
            for section in conf.config.sections():
                conf.section = section
                category = section.split(".")[0]
                sect = section.split(".")[-1]
                # Elevate global to root
                key = plugin if sect == "global" else "{}|{}|{}".format(plugin, category, sect)
                retval[key] = dict(helptext=None, options=OrderedDict())

                for option, params in conf.defaults[section].items():
                    if option == "helptext":
                        retval[key]["helptext"] = params
                        continue
                    initial_value = conf.config_dict[option]
                    initial_value = "none" if initial_value is None else initial_value
                    retval[key]["options"][option] = ControlPanelOption(
                        title=option,
                        dtype=params["type"],
                        group=params["group"],
                        default=params["default"],
                        initial_value=initial_value,
                        choices=params["choices"],
                        is_radio=params["gui_radio"],
                        rounding=params["rounding"],
                        min_max=params["min_max"],
                        helptext=params["helptext"])
        logger.debug("Formatted Config for GUI: %s", retval)
        return retval

    def _build_header(self):
        """ Build the dynamic header text. """
        header_frame = ttk.Frame(self)
        var = tk.StringVar()
        lbl = ttk.Label(header_frame, textvariable=var, anchor=tk.W, style="H2.TLabel")
        lbl.pack(fill=tk.X, expand=True, side=tk.TOP)
        header_frame.pack(fill=tk.X, padx=5, pady=(5, 0), side=tk.TOP)
        self._vars["header"] = var

    def select_options(self, section, subsections):
        """ Display the page for the given section and subsections. </s> remove     def scan_for_plugin_configs(self):
        """ Scan for config.ini file locations """
        global _CONFIGS, _CONFIG_FILES  # pylint:disable=global-statement
        root_path = os.path.abspath(os.path.dirname(sys.argv[0]))
        plugins_path = os.path.join(root_path, "plugins")
        logger.debug("Scanning path: '%s'", plugins_path)
        configs = dict()
        for dirpath, _, filenames in os.walk(plugins_path):
            if "_config.py" in filenames:
                plugin_type = os.path.split(dirpath)[-1]
                config = self.load_config(plugin_type)
                configs[plugin_type] = config
        logger.debug("Configs loaded: %s", sorted(list(configs.keys())))
        keys = list(configs.keys())
        for key in ("extract", "train", "convert"):
            if key in keys:
                _CONFIG_FILES.append(keys.pop(keys.index(key)))
        _CONFIG_FILES.extend([key for key in sorted(keys)])
        _CONFIGS = configs
        return configs

    @staticmethod
    def load_config(plugin_type):
        """ Load the config to generate config file if it doesn't exist and get filename """
        # Load config to generate default if doesn't exist
        mod = ".".join(("plugins", plugin_type, "_config"))
        module = import_module(mod)
        config = module.Config(None)
        logger.debug("Found '%s' config at '%s'", plugin_type, config.configfile)
        return config

 </s> add  </s> remove def popup_config(name, configuration):
    """ Open the settings for the requested configuration file and close any already active
    pop-ups.
 </s> add class _State():
    """ Holds the existing config files and the current state of the popup window. """
    def __init__(self):
        self._popup = None
        # The GUI Config cannot be scanned until GUI is launched, so this is populated
        # on the first call to load the settings
        self._configs = dict()
        gui_style.configure('H1.TLabel',
                            font=(self._config.default_font[0],
                                  self._config.default_font[1] + 4,
                                  "bold"))
        gui_style.configure('H2.TLabel',
                            font=(self._config.default_font[0],
                                  self._config.default_font[1] + 2,
                                  "bold"))
      def set_styles(self):
          """ Set global custom styles """
          gui_style = ttk.Style()
          gui_style.configure('TLabelframe.Label', foreground="#0046D5", relief=tk.SOLID)
        gui_style.configure('H1.TLabel',
                            font=(self._config.default_font[0],
                                  self._config.default_font[1] + 4,
                                  "bold"))
        gui_style.configure('H2.TLabel',
                            font=(self._config.default_font[0],
                                  self._config.default_font[1] + 2,
                                  "bold"))
  
      def build_gui(self, rebuild=False):
          """ Build the GUI """
          logger.debug("Building GUI")
          if not rebuild:
keep keep keep add keep keep keep keep keep
 GUI: Consolidate settings to single menu 
scripts/gui.py