Returns a list with keys of this DAWG that are prefixes of the ``key``.
334116
def prefixes(self, key):
        '''
        
        '''
        res = []
        index = self.dct.ROOT
        if not isinstance(key, bytes):
            key = key.encode('utf8')

        pos = 1

        for ch in key:
            index = self.dct.follow_char(int_from_byte(ch), index)
            if not index:
                break

            if self._has_value(index):
                res.append(key[:pos].decode('utf8'))
            pos += 1

        return res
892990
def get_keys(self, models, key=None):
        
        return list(set(map(lambda value: value.get_attribute(key) if key else value.get_key(), models)))
1299704
def get_keys(self):
        
        return [(self.first_key + i) for i in range(0, len(self.targets))]
926051
def keys(self):
        
        if self._keys is None:
            self._keys = KeyList(self._version, account_sid=self._solution['sid'], )
        return self._keys
297544
def prefix(self, keys):
        
        assert isinstance(keys, tuple)

        self._prefix = keys
        self._load_prefix_binding()
1062999
def keys_list(gandi, fqdn):
    """"""
    keys = gandi.dns.keys(fqdn)
    output_keys = ['uuid', 'algorithm', 'algorithm_name', 'ds', 'flags',
                   'status']
    for num, key in enumerate(keys):
        if num:
            gandi.separator_line()
        output_generic(gandi, key, output_keys, justify=15)
    return keys
1066385
def get_keys(self) -> typing.List[str]:
        
        keys = []
        for key in self.data.keys():
            if key not in ['__header__', '__version__', '__globals__']:
                keys.append(key)
        return keys
680731
def key_paths(self):
    """"""
    if self._wow64_key_path:
      return [self._key_path, self._wow64_key_path]
    return [self._key_path]
771210
def get_all_keys(self, headers=None, **params):
        
        key = Key(self.name, self.contained_key)
        return SimpleResultSet([key])
671338
def _map_and_prefix_keys(self, key_iterable, key_prefix):
        
        # Check it just once ...
        key_extra_len=len(key_prefix)
        if key_prefix and self.do_check_key:
            self.check_key(key_prefix)

        # server (_Host) -> list of unprefixed server keys in mapping
        server_keys = {}

        prefixed_to_orig_key = {}
        # build up a list for each server of all the keys we want.
        for orig_key in key_iterable:
            if isinstance(orig_key, tuple):
                # Tuple of hashvalue, key ala _get_server(). Caller is essentially telling us what server to stuff this on.
                # Ensure call to _get_server gets a Tuple as well.
                str_orig_key = str(orig_key[1])
                server, key = self._get_server((orig_key[0], key_prefix + str_orig_key)) # Gotta pre-mangle key before hashing to a server. Returns the mangled key.
            else:
                str_orig_key = str(orig_key) # set_multi supports int / long keys.
                server, key = self._get_server(key_prefix + str_orig_key)

            # Now check to make sure key length is proper ...
            if self.do_check_key:
                self.check_key(str_orig_key, key_extra_len=key_extra_len)

            if not server:
                continue

            if server not in server_keys:
                server_keys[server] = []
            server_keys[server].append(key)
            prefixed_to_orig_key[key] = orig_key

        return (server_keys, prefixed_to_orig_key)
707108
def keys(self):
        
        return sorted([k for k in dir(self) if
                       k[0:1] != '_' and k != 'keys' and not k.isupper() and
                       not inspect.ismethod(getattr(self, k)) and
                       not (hasattr(self.__class__, k) and
                            isinstance(getattr(self.__class__, k),
                                       property)) and
                       not isinstance(getattr(self, k), property)])
754564
def get_other_keys(self, key, including_current=False):
        
        other_keys = []
        if key in self:
            other_keys.extend(self.__dict__[str(type(key))][key])
            if not including_current:
                other_keys.remove(key)
        return other_keys
1272674
def get_keys(self, lst):
        
        pk_name = self.get_pk_name()
        return [getattr(item, pk_name) for item in lst]
1132264
def prefixes(self):
        
        pset = set()
        for n in self.nodes():
            pfx = self.prefix(n)
            if pfx is not None:
                pset.add(pfx)
        return list(pset)
1173801
def iterkeys(self):
        ""
        return chain(self._pb.StringMap.keys(),
                     self._pb.IntMap.keys(),
                     self._pb.FloatMap.keys(),
                     self._pb.BoolMap.keys())
934502
def keys(self):
		
		if hasattr(self._nodes, 'iterkeys'):
			return self._nodes.keys()
		else:
			return tuple(self._nodes.keys())
763258
def items(self):
        ''''''
        return [(self.keys[x], self.values[x]) for x in range(len(self.keys))]