Return the alias name for the relative header or None if nonexist.
345773
def has_alias(self, header):
        """"""
        try:
            # Force to lower case (issue #1126)
            return self._limits[self.plugin_name + '_' + header.lower() + '_' + 'alias'][0]
        except (KeyError, IndexError):
            # logger.debug("No alias found for {}".format(header))
            return None
608378
def get_alias(self, alias):
        
        alias = alias or {}
        return [k for k, v in alias.items() if self.mnemonic in v]
1365561
def find_entry_name_of_alias(self, alias):
        
        if alias in self.aliases:
            name = self.aliases[alias]
            if name in self.entries:
                return name
            else:
                # Name wasn't found, possibly merged or deleted. Now look
                # really hard.
                for name, entry in self.entries.items():
                    aliases = entry.get_aliases(includename=False)
                    if alias in aliases:
                        if (ENTRY.DISTINCT_FROM not in entry or
                                alias not in entry[ENTRY.DISTINCT_FROM]):
                            return name

        return None
429822
def get_header(self, name, default=None):
        
        return self._handler.headers.get(name, default)
109418
def get_header(self, header_name, default=None):
        
        return self.headers.get(
            header_name, self.unredirected_headers.get(header_name, default))
770068
def getheader(self, name, default=None):
        """"""
        return self.aiohttp_response.headers.get(name, default)
776939
def not_as_alias_handler(names_list):
    """"""
    list_ = list()
    for alias in names_list:
        list_.append(alias.name)
    return list_
783763
def aliased_slot_name(self, slot: SLOT_OR_SLOTNAME) -> str:
        
        if isinstance(slot, str):
            slot = self.schema.slots[slot]
        return slot.alias if slot.alias else slot.name
1284437
def getheader(self, which, use_hash=None, polish=True):
        """"""
        header = getheader(
            which,
            use_hash=use_hash,
            target=self.target,
            no_tco=self.no_tco,
            strict=self.strict,
        )
        if polish:
            header = self.polish(header)
        return header
1106186
def header_canonical(self, header_name):
        """"""
        # Translate as stated in the docs:
        # https://docs.djangoproject.com/en/1.6/ref/request-response/#django.http.HttpRequest.META
        header_name = header_name.lower()
        if header_name == 'content-type':
            return 'CONTENT-TYPE'
        elif header_name == 'content-length':
            return 'CONTENT-LENGTH'
        return 'HTTP_%s' % header_name.replace('-', '_').upper()
703050
def _find_alias(FunctionName, Name, FunctionVersion=None,
                region=None, key=None, keyid=None, profile=None):
    '''
    
    '''
    conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)

    args = {
        'FunctionName': FunctionName
    }
    if FunctionVersion:
        args['FunctionVersion'] = FunctionVersion

    for aliases in __utils__['boto3.paged_call'](conn.list_aliases, **args):
        for alias in aliases.get('Aliases'):
            if alias['Name'] == Name:
                return alias
    return None
756384
def get_header(self, name, default_value=None):
        
        name_lower = name.lower()
        for value in self.headers:
            if value[0].lower() == name_lower:
                return value[1]

        return default_value
13531
def get_name(self, use_alias=True):
        
        if self.desc:
            direction = 'DESC'
        else:
            direction = 'ASC'

        if use_alias:
            return '{0} {1}'.format(self.field.get_identifier(), direction)
        return '{0} {1}'.format(self.field.get_select_sql(), direction)
1209836
def name(self):
        """"""
        if self.path:
            # follow h5py convention: add leading slash
            name = self.path
            if name[0] != '/':
                name = '/' + name
            return name
        return None
1296120
def put_alias(self, using=None, **kwargs):
        
        return self._get_connection(using).indices.put_alias(index=self._name, **kwargs)
717804
def get_name(self):
        """"""
        if self.given_name is None:
            # Name according to host
            if self.hostname is None:
                name = _("Console")
            else:
                name = self.hostname
            # Adding id to name
            client_id = self.id_['int_id'] + u'/' + self.id_['str_id']
            name = name + u' ' + client_id
        elif self.given_name in ["Pylab", "SymPy", "Cython"]:
            client_id = self.id_['int_id'] + u'/' + self.id_['str_id']
            name = self.given_name + u' ' + client_id
        else:
            name = self.given_name + u'/' + self.id_['str_id']
        return name
26418
def header(self, name, default=None):
        
        wsgi_header = "HTTP_{0}".format(name.upper())

        try:
            return self.env_raw[wsgi_header]
        except KeyError:
            return default