Get the key of the section header

        :param key: the key name
        :param spaces: spaces to set at the beginning of the header
174908
def get_key_section_header(self, key, spaces):
        
        if key in self.section_headers:
            header = self.section_headers[key]
        else:
            return ''

        return header
9755
def _encode_header(key: str, pdict: Dict[str, str]) -> str:
    
    if not pdict:
        return key
    out = [key]
    # Sort the parameters just to make it easy to test.
    for k, v in sorted(pdict.items()):
        if v is None:
            out.append(k)
        else:
            # TODO: quote if necessary.
            out.append("%s=%s" % (k, v))
    return "; ".join(out)
735472
def get(self, key):
        
        keystr = str(key)
        res = None

        try:
            res = self.ctx[keystr]
        except KeyError:
            for k, v in self.ctx.items():
                if "name" in v and v["name"].lower() == keystr.lower():
                    res = v
                    break

        return res
236082
def get(self, section, key):
        
        line = self._make_line(key)
        for line in self.get_line(section, line):
            yield line.value
682945
def keys(self, namespace, prefix=None, limit=None, offset=None):
        """"""
        params = [namespace]
        query = 'SELECT key FROM gauged_keys WHERE namespace = %s'
        if prefix is not None:
            query += ' AND key LIKE %s'
            params.append(prefix + '%')
        if limit is not None:
            query += ' LIMIT %s'
            params.append(limit)
        if offset is not None:
            query += ' OFFSET %s'
            params.append(offset)
        cursor = self.cursor
        cursor.execute(query, params)
        return [key for key, in cursor]
6816
def get_name(self, key):
        '''
        '''
        try:
            return self.nameDict[key]
        except IndexError as e:
            print 'IndexError {0}: {1}'.format(e.errno, e.strerror)
407238
def getKey(k)
      return nil if k > @nitems || k <= 0
      pos = SIZEOF_BLOCK_HEADER + (SIZEOF_KEY * (k - 1))
      keydata = @data[pos, SIZEOF_KEY]
      data2key(keydata)
    end
880542
def _normalized_keys(self, section, items):
        # type: (str, Iterable[Tuple[str, Any]]) -> Dict[str, Any]
        
        normalized = {}
        for name, val in items:
            key = section + "." + _normalize_name(name)
            normalized[key] = val
        return normalized
328074
def safe_get(self, section, key):
        
        try:
            #Use full parent function so we can replace it in the class
            # if desired
            return configparser.RawConfigParser.get(self, section, key)
        except (configparser.NoSectionError,
                configparser.NoOptionError):
            return None
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
1011091
def get(self):
        
        header = {}
        if self.key is not None and self.value is not None:
            header[self.key] = self.value
        return header
1244946
public String getKeyValue(String strSection, String key) throws IOException {
	Object o = getSection(strSection).get(key.toLowerCase());
	if (o == null) throw new IOException("key " + key + " doesn't exist in section " + strSection);
	return (String) o;

    }
429317
def header(self, title, level, key, width=80):
        
        linestyle_code = {1: "=", 2: "-", 3: "~"}
        if level not in linestyle_code:
            raise Exception("'level' argument has to be 1, 2 or 3")
        else:
            linestyle = linestyle_code[level]

        if key:
            return "\n".join([".. _%s" % key, "", title, linestyle * width])
        else:
            return "\n".join([title, "=" * width])
1323832
def _get(self, key, section=None, default=_onion_dict_guard):
        
        if section is not None:
            section_dict = self.__sections.get(section, {})
            if key in section_dict:
                return section_dict[key]
        for d in self.__dictionaries:
            if key in d:
                return d[key]
        if default is _onion_dict_guard:
            raise KeyError(key)
        else:
            return default
734698
String getNamespacedKey(CacheNamespace cacheNamespace, String key) {
        String namespaceIndicator = getNamespaceIndicator(cacheNamespace);

        if (cacheNamespace.isNamespaceExpirationRequired() == false) {
            return namespaceIndicator + ":" + key;
        }

        String namespaceIndicatorKey = namespaceIndicator + NAMESPACE_NAME_SQUENCE_SEPARATOR;
        long namespaceSquence = memcachedClient.incr(namespaceIndicatorKey, 0L, System.currentTimeMillis(),
                DEFAULT_NAMESPACE_SEQUENCE_EXPIRY_SECONDS);

        return namespaceIndicatorKey + namespaceSquence + ":" + key;
    }
284220
def get(self, key):  
        
        res = self.connection.get(key)
        print(res)
        return res
853654
public final static String getHeader(String headerKey, String charset) {
		return ServletUtil.getHeader(getServletRequest(), headerKey, charset);
	}