Return a name for the given key
        Argument:
        key -- Pokemon number id (int)
6816
def get_name(self, key):
        '''
        '''
        try:
            return self.nameDict[key]
        except IndexError as e:
            print 'IndexError {0}: {1}'.format(e.errno, e.strerror)
1248576
def data_key(data) :
    ""
    if isinstance(data, (bytes, float, frozenset, int, str, tuple)) :
        result = data
    else :
        # data itself is non-hashable
        result = id(data)
    #end if
    return \
        result
150228
def _get_key_id(alias, region=None, key=None, keyid=None, profile=None):
    '''
    
    '''
    key_metadata = describe_key(
        alias, region, key, keyid, profile
    )['key_metadata']
    return key_metadata['KeyId']
122857
def get(self, key, name=None):
        """"""
        if name is None:
            self.nodename = self.local_name
            self.nodeid = self.local_id
        else:
            self.logger.debug('Replacing nodename "{0}" with "{1}"'.format(self.nodename, name))
            self.nodename = name
            self.find_name()
        return get_value(self.stats(), fix_key(key))
451572
def key(self, att=None):
        """"""
        if att is not None:
            return self._key[self.id][att]
        else:
            return self._key[self.id]
1029519
def _id_or_key(list_item):
    '''
    
    '''
    if isinstance(list_item, dict):
        if 'id' in list_item:
            return list_item['id']
        if 'key' in list_item:
            return list_item['key']
    return list_item
1088584
def _parseKeyName(self, name):
        
        if name.endswith(Store.theInfoExtension):
            return {'type': 'info'}

        match = self.keyPattern.match(name)
        if not match:
            return None

        match = match.groupdict()
        match.update(type='diff')

        return match
1285813
def getkey(mapping, value, default=None, use_id=False):
    '''
    '''
    if use_id:
        for key, val in mapping.items():
            if val is value:
                return key
    else:
        for key, val in mapping.items():
            if val == value:
                return key
    return default
227013
def argument(self, key=None):
        
        if key is None:
            return self._args.arguments()

        return self._args.argument(key)
488194
def identifier(key)
      key &&= key.to_sym
      return unless Rudy::ID_MAP.has_key?(key)
      Rudy::ID_MAP[key]
    end
1013758
def key_by(self, key_selector):
        
        op = Operator(
            _generate_uuid(),
            OpType.KeyBy,
            "KeyBy",
            other=key_selector,
            num_instances=self.env.config.parallelism)
        return self.__register(op)
1121112
def get_dataset_key(self, key, **kwargs):
        
        return get_key(key, self.ids.keys(), **kwargs)
67254
def _buildNewKeyname(self,key,prepend):
        

        if len(prepend+key) <= 8: _new_key = prepend+key
        else: _new_key = str(prepend+key)[:8]

        return _new_key
1208356
def hkeys(self, name):
        
        with self.pipe as pipe:
            f = Future()
            res = pipe.hkeys(self.redis_key(name))

            def cb():
                m_decode = self.memberparse.decode
                f.set([m_decode(v) for v in res.result])

            pipe.on_execute(cb)
            return f
534080
def key(self):
        """"""
        if self.curie is None:
            return self.name
        return ":".join((self.curie.name, self.name))
1087529
def _get_key_data(d, key):
    
    d2 = ""
    try:
        d2 = d[key]
    except KeyError:
        logger_dataframes.info("get_key_data: KeyError: {}".format(key))
    return d2
93945
def _get_name(self, key):
        
        if key in self.display_names:
            return self.display_names[key]

        return key.capitalize()