:returns: a list of usable keys
        :rtype: list
775287
def keys(self):
        

        keys = list()

        for attribute_name, type_instance in inspect.getmembers(self):

            # ignore parameters with __ and if they are methods
            if attribute_name.startswith('__') or inspect.ismethod(type_instance):

                continue

            keys.append(attribute_name)

        return keys
1266180
def keys(self):
        
        if len(self._row_name_list) != len(self._rows):
            raise NotImplementedError("You can't get row keys for a FVM that doesn't have all rows keyed")

        return self.row_names()
497987
def get_all_keys(self):
        
        all_keys = []
        for keys in self._index.values():
            all_keys.extend(keys)
        return all_keys
608966
def generate_valid_keys():
    
    valid_keys = []
    for minimum, maximum in RANGES:
        for i in range(ord(minimum), ord(maximum) + 1):
            valid_keys.append(chr(i))
    return valid_keys
434861
def keys(self):
        """"""
        s = set()
        for config in self.__configs:
            s |= config.keys()
        return s
1142302
def __get_keys(self):
        
        keys = list()
        tree_node = self
        while tree_node is not None and tree_node.key is not None:
            keys.insert(0, tree_node.key)
            tree_node = tree_node.parent
        return keys
396519
def keys(self):
        """"""
        keys = []
        for app_name, __ in self.items():
            keys.append(app_name)
        return keys
1144032
def keys(self):
        
        for field in self._client.hkeys(self.key_prefix):
            yield self._decode(field)
905263
def storage_keys(self):
        
        if not self._module:
            return []
        self._storage_init()
        module_name = self._module.module_full_name
        return self._storage.storage_keys(module_name)
135287
def _list_keys(self):
        
        req = self.request(self.uri + '/keys')
        keys = req.get().json()
        if keys:
            self._keys = {}
            for key in keys:
                self._keys[key['id']] = Key(key, self)
        else:
            self._keys = {}
1212317
def get_help_keys(self):
        
        help_keys = {}
        for k, v in self.help_context.items():
            if isinstance(v, tuple):
                help_keys[k] = v[0]
            else:
                help_keys[k] = v
        return help_keys
1296597
def _ipython_key_completions_(self):
        
        return [key for key in self._data._ipython_key_completions_()
                if key not in self._data.data_vars]
765404
def get_used_key_frames(self):
        """"""

        skl = self.key_frame_list.sorted_key_list()
        # each element in used_key_frames is a tuple (key_name, key_dict)
        used_key_frames = []
        for kf in skl:
            if kf in self.dct['keys']:
                used_key_frames.append((kf, self.dct['keys'][kf]))
        return used_key_frames
945272
def get_points(self):
        
        return [(k, self.runtime._ring[k]) for k in self.runtime._keys]
217817
def list_keys(self):
    
    return [k for k, el in self._keystore.items() if not el.is_expired]
1312430
def signing_keys(self):
        
        if self._signing_keys is None:
            self._signing_keys = SigningKeyList(self._version, account_sid=self._solution['sid'], )
        return self._signing_keys
1299704
def get_keys(self):
        
        return [(self.first_key + i) for i in range(0, len(self.targets))]