environment key value pairs need to be joined by an equal, and 
       exported at the end.

      Parameters
      ==========
      section: the list of values to return as a parsed list of lines
      name: the name of the section to write (e.g., files)
183313
def create_env_section(pairs, name):
    '''

    '''
    section = ['%' + name ]
    for pair in pairs:
        section.append("export %s" %pair)
    return section
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()]
1347761
function(obj, section, options = {}) {
    var children, dotSplit, out, safe;
    if (arguments.length === 2) {
      options = section;
      section = void 0;
    }
    if (options.separator == null) {
      options.separator = ' = ';
    }
    if (options.eol == null) {
      options.eol = !options.ssh && process.platform === "win32" ? "\r\n" : "\n";
    }
    if (options.escape == null) {
      options.escape = true;
    }
    safe = module.exports.safe;
    dotSplit = module.exports.dotSplit;
    children = [];
    out = "";
    Object.keys(obj).forEach(function(k, _, __) {
      var val;
      val = obj[k];
      if (val && Array.isArray(val)) {
        return val.forEach(function(item) {
          return out += safe(`${k}[]`) + options.separator + safe(item) + options.eol;
        });
      } else if (val && typeof val === "object") {
        return children.push(k);
      } else if (typeof val === 'boolean') {
        if (val === true) {
          return out += safe(k) + options.eol;
        } else {

        }
      } else {
        // disregard false value
        return out += safe(k) + options.separator + safe(val) + options.eol;
      }
    });
    if (section && out.length) {
      out = "[" + safe(section) + "]" + options.eol + out;
    }
    children.forEach((k, _, __) => {
      var child, nk;
      // escape the section name dot as some daemon could not parse it
      nk = options.escape ? dotSplit(k).join('\\.') : k;
      child = module.exports.stringify(obj[k], (section ? section + "." : "") + nk, options);
      if (out.length && child.length) {
        out += options.eol;
      }
      return out += child;
    });
    return out;
  }
279385
def get_key_value_pairs(self, subsystem, filename):
        
        assert subsystem in self
        return util.read_key_value_pairs_from_file(self.per_subsystem[subsystem], subsystem + '.' + filename)
1190243
def get_section_path(section):
    
    keys = []
    p = section
    for i in range(section.depth):
        keys.insert(0, p.name)
        p = p.parent
    return keys
71009
def _parse_region(self, rec, line_iter):
        
        had_info = False
        keyvals, section = self._parse_keyvals(line_iter)

        if keyvals:
            rec.metadata = keyvals[0]
        while section and section[0] != "STUDY":
            had_info = True
            keyvals, next_section = self._parse_keyvals(line_iter)
            attr_name = self._sections[section[0]]
            if attr_name in self._nolist:
                try:
                    keyvals = keyvals[0]
                except IndexError:
                    keyvals = {}

            setattr(rec, attr_name, keyvals)
            section = next_section
        return rec, had_info
1063085
def get_section_key_line(self, data, key, opt_extension=''):
        
        start = 0
        init = 0
        while start != -1:
            start = self.get_next_section_start_line(data[init:])
            init += start
            if start != -1:
                if data[init].strip().lower() == self.opt[key] + opt_extension:
                    break
                init += 1
        if start != -1:
            start = init
        return start
325710
public final void value_section() throws RecognitionException {
		try {
			// src/main/resources/org/drools/compiler/lang/dsl/DSLMapWalker.g:105:5: ( ^( VT_ENTRY_VAL ( value_sentence )+ ) )
			// src/main/resources/org/drools/compiler/lang/dsl/DSLMapWalker.g:105:7: ^( VT_ENTRY_VAL ( value_sentence )+ )
			{
			match(input,VT_ENTRY_VAL,FOLLOW_VT_ENTRY_VAL_in_value_section329); 
			match(input, Token.DOWN, null); 
			// src/main/resources/org/drools/compiler/lang/dsl/DSLMapWalker.g:105:22: ( value_sentence )+
			int cnt11=0;
			loop11:
			while (true) {
				int alt11=2;
				int LA11_0 = input.LA(1);
				if ( (LA11_0==VT_LITERAL||LA11_0==VT_SPACE||LA11_0==VT_VAR_REF) ) {
					alt11=1;
				}

				switch (alt11) {
				case 1 :
					// src/main/resources/org/drools/compiler/lang/dsl/DSLMapWalker.g:105:22: value_sentence
					{
					pushFollow(FOLLOW_value_sentence_in_value_section331);
					value_sentence();
					state._fsp--;

					}
					break;

				default :
					if ( cnt11 >= 1 ) break loop11;
					EarlyExitException eee = new EarlyExitException(11, input);
					throw eee;
				}
				cnt11++;
			}

			match(input, Token.UP, null); 

			}


			    entry_stack.peek().valuebuffer.append(" ");

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
		}
	}
1266562
def __import_vars(self, env_file):
        """"""
        with open(env_file, "r") as f:  # pylint: disable=invalid-name
            for line in f:
                try:
                    line = line.lstrip()
                    if line.startswith('export'):
                        line = line.replace('export', '', 1)
                    key, val = line.strip().split('=', 1)
                except ValueError:  # Take care of blank or comment lines
                    pass
                else:
                    if not callable(val):
                        if self.verbose_mode:
                            if key in self.app.config:
                                print(
                                    " * Overwriting an existing config var:"
                                    " {0}".format(key))
                            else:
                                print(
                                    " * Setting an entirely new config var:"
                                    " {0}".format(key))
                        self.app.config[key] = re.sub(
                            r"\A[\"']|[\"']\Z", "", val)
272786
def set(self, section, key, value):
        

        conf = self.get_section_config(section)
        if isinstance(value, bool):
            conf[key] = str(value)
        else:
            conf[key] = value
        self.set_section_config(section, conf)
376109
def read_key_value_pairs_from_file(*path):
    
    with open(os.path.join(*path)) as f:
        for line in f:
            yield line.split(' ', 1)
236082
def get(self, section, key):
        
        line = self._make_line(key)
        for line in self.get_line(section, line):
            yield line.value
875992
def _unify_values(self, section, vars):
        
        sectiondict = {}
        try:
            sectiondict = self._sections[section]
        except KeyError:
            if section != self.default_section:
                raise NoSectionError(section)
        # Update with the entry specific variables
        vardict = {}
        if vars:
            for key, value in vars.items():
                if value is not None:
                    value = str(value)
                vardict[self.optionxform(key)] = value
        return _ChainMap(vardict, sectiondict, self._defaults)
1201796
def items(self, section):
        
        items = []
        for k, v in ConfigParser.items(self, section):
            if self.is_secure_option(section, k):
                v = self.get(section, k)
            if v == '!!False!!':
                v = False
            items.append((k, v))
        return items
174065
def _get_section_values(self, config, section):
        
        src_host = self._get_hosts_from_names(config.get(section, 'src.host')) \
            if config.has_option(section, 'src.host') else None
        src_file = [self._get_abs_filepath(config.get(section, 'src.file'))] \
            if config.has_option(section, 'src.file') else None
        if src_host is None and src_file is None:
            raise conferr('Section "%s" gets no sources' % section)

        dst_host = self._get_hosts_from_names(config.get(section, 'dst.host')) \
            if config.has_option(section, 'dst.host') else None
        dst_file = [self._get_abs_filepath(config.get(section, 'dst.file'))] \
            if config.has_option(section, 'dst.file') else None
        if dst_host is None and dst_file is None:
            raise conferr('Section "%s" gets no destinations' % section)

        return (src_host, src_file, dst_host, dst_file)
996031
public static String getValueWithGlobalDefault(String section, ConfigConstant key) {
    String value = getValue(section, key);
    return (Strings.isNullOrEmpty(value) ? getGlobalValue(key) : value);
  }
1220915
def config_section(self):
        
        names = []
        cmd = self
        while cmd.parent:
            names.append(cmd.name)
            cmd = cmd.parent
        if not names:
            return self.name
        else:
            return ' '.join(reversed(names))