Parses `extras_require` configuration file section.

        :param dict section_options:
497708
def parse_section_extras_require(self, section_options):
        
        parse_list = partial(self._parse_list, separator=';')
        self['extras_require'] = self._parse_section_to_dict(
            section_options, parse_list)
832376
def config_parser_to_dict(config_parser):
    
    response = {}

    for section in config_parser.sections():
        for option in config_parser.options(section):
            response.setdefault(section, {})[option] = config_parser.get(section, option)

    return response
299663
def get_config_set(self, section, option):
		
		values = set()
		for cp, filename, fp in self.layers:
			filename = filename # pylint
			fp = fp # pylint
			if cp.has_option(section, option):
				values.add(cp.get(section, option))
		return values
266311
def get_config_value(config_file, section, variable):
    
    try:
        parser = ConfigParser.SafeConfigParser()
        parser.read(config_file)
        return parser.get(section, variable)
    except:
        return None
1227819
def _extract_section(sect_req, elffile, mem=None):
        
        for nseg, section in enumerate(elffile.iter_sections()):
            request = sect_req.get(section.name, None)
            if request:
                request.set_found(True)
                request.set_sect_properties(section.header.sh_addr,
                                            section.header.sh_size)
                if mem:
                    mem.add_vma(section.header.sh_addr, section.data())
                else:
                    request.memory.add_vma(section.header.sh_addr, section.data())
448251
def parse(self, requires_cfg=True):
        
        self._parse_default()
        self._parse_config(requires_cfg)
        self._parse_env()
794237
def set_from_config_file(self, filename):
        
        if not os.path.exists(filename):
            raise LintConfigError(u"Invalid file path: {0}".format(filename))
        self._config_path = os.path.abspath(filename)
        try:
            parser = ConfigParser()
            parser.read(filename)

            for section_name in parser.sections():
                for option_name, option_value in parser.items(section_name):
                    self.set_option(section_name, option_name, ustr(option_value))

        except ConfigParserError as e:
            raise LintConfigError(ustr(e))
802517
def check_config(self, section, name, has_default=False, value=None, allowEmpty=False):
    
    

    cfg = self.config
    if not cfg.has_key(section) or not cfg.get(section).has_key(name):
      if not has_default:
        self.config_errors.append("%s: %s -> missing" % (section, name))
        return False
      else:
        return True

    v = cfg.get(section).get(name)

    if v == "" and not allowEmpty:
      self.config_errors.append("%s: %s -> empty" % (section, name))
      return False
    return True
1137118
def load_extra(cls, filename):
    
    try:
      with open(filename, 'rb') as configuration_file:
        cls.load_extra_data(configuration_file.read())
        sys.stderr.write("Config successfully loaded from {0:s}\n".format(
            filename))
        return True
    except IOError:
      return False
416897
def has_section(self, section) -> bool:
        
        self.config.read(self.filepath)
        return self.config.has_section(section)
1197199
def parse_sections(sections_desc)
      require "json"

      sections_desc = sections_desc.to_json if sections_desc.class == Hash

      begin
        sections_json = JSON.parse(sections_desc)
      rescue JSON::ParserError => e
        raise "There was a problem parsing your JSON string for sections: #{e}"
      end

      sections_json.collect do |name, v|
        Section.new(name: name.to_s, prefix: v["prefix"], labels: v["labels"], options: @options)
      end
    end
842129
def filesystem_from_config_dict(config_fs):
    
    if "module" not in config_fs:
        print("Key 'module' should be defined for the filesystem provider ('fs' configuration option)", file=sys.stderr)
        exit(1)

    filesystem_providers = get_filesystems_providers()
    if config_fs["module"] not in filesystem_providers:
        print("Unknown filesystem provider "+config_fs["module"], file=sys.stderr)
        exit(1)

    fs_class = filesystem_providers[config_fs["module"]]
    fs_args_needed = fs_class.get_needed_args()

    fs_args = {}
    for arg_name, (arg_type, arg_required, _) in fs_args_needed.items():
        if arg_name in config_fs:
            fs_args[arg_name] = arg_type(config_fs[arg_name])
        elif arg_required:
            print("fs option {} is required".format(arg_name), file=sys.stderr)
            exit(1)

    try:
        return fs_class.init_from_args(**fs_args)
    except:
        print("Unable to load class " + config_fs["module"], file=sys.stderr)
        raise
607392
def section(self, section, skip=['type', 'order']):
        
        return [(key, val) for key, val in self.parser.items(section)
                if key not in skip]
539180
def get_section(section_name, cfg_file=cfg_file):
    
    parser = get_parser(cfg_file=cfg_file)
    options = parser.options(section_name)
    result = {}
    for option in options:
        result[option] = parser.get(section=section_name, option=option)
    return result
1274536
def parse_section_data_files(self, section_options):
        
        parsed = self._parse_section_to_dict(section_options, self._parse_list)
        self['data_files'] = [(k, v) for k, v in parsed.items()]
1116714
def _config_section(config, section):
    """"""
    path = os.path.join(config.get('config_path'), config.get('config_file'))
    conf = _config_ini(path)
    return conf.get(section)
617981
def parse_config_file(path: str, final: bool = True) -> None:
    
    return options.parse_config_file(path, final=final)