Returns a list of ConfigMap keys.
503555
def keys(self):
        ""
        return (list(self._pb.IntMap.keys()) + list(self._pb.StringMap.keys()) +
                list(self._pb.FloatMap.keys()) + list(self._pb.BoolMap.keys()))
407811
def get_all_config(self):
        ''''''
        return json.dumps(self.config, indent=4, sort_keys=True, separators=(',', ':'))
1144754
def keys(self):
        
        if self._keys is None:
            self._keys = KeyList(self._version, fleet_sid=self._solution['sid'], )
        return self._keys
558023
def keys(self):
        """"""
        keys = Struct.keys(self)
        for key in (
                '_cloud_provider',
                '_naming_policy',
                '_setup_provider',
                'known_hosts_file',
                'repository',
        ):
            if key in keys:
                keys.remove(key)
        return keys
32514
def keys_values(data, *keys):
    """"""
    values = []
    if is_mapping(data):
        for key in keys:
            if key in data:
                values.extend(ensure_list(data[key]))
    return values
396519
def keys(self):
        """"""
        keys = []
        for app_name, __ in self.items():
            keys.append(app_name)
        return keys
1133411
def config(param_map, mastercode=DEFAULT_MASTERCODE):
    """"""
    pmap = {Config.mastercode: mastercode}
    pmap.update(param_map)
    processed_params = dict(_process_params(pmap))
    return processed_params
170810
def config_keys(self, sortkey = False):
        
        if sortkey:
            items = sorted(self.items())
        else:
            items = self.items()
        for k,v in items:
            if isinstance(v, ConfigTree):
                for k2 in v.config_keys(sortkey):
                    yield k + '.' + k2
            else:
                yield k
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)
768053
def keys(self, globpat = None):
        

        if globpat is None:
            files = self.root.rglob('*')
        else:
            files = self.root.glob(globpat)
        return [self._normalized(p) for p in files if p.is_file()]
367430
def get_config(self):
        
        # Fill this dict with config data
        return {
            'hash_name': self.hash_name,
            'dim': self.dim,
            'projection_count': self.projection_count,
            'normals': self.normals,
            'tree_root': self.tree_root,
            'minimum_result_size': self.minimum_result_size
        }
321253
def get_options():
    """"""
    options = collections.defaultdict(list)
    for opt_class in config_factory.get_options():
        if not issubclass(opt_class, config_base.Options):
            continue
        config_options = opt_class(None)
        options[config_options.group_name].extend(config_options.list())
    return [(key, value) for key, value in options.items()]
1297202
def config_dict(config):
    
    return dict(
        (key, getattr(config, key))
        for key in config.values
    )
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
680731
def key_paths(self):
    """"""
    if self._wow64_key_path:
      return [self._key_path, self._wow64_key_path]
    return [self._key_path]
736987
def keys():
    """"""
    for admin in current_app.config['ADMIN_USERS']:
        try:
            db.get_db()  # init db on global app context
            keys = ApiKey.find_by_user(admin)
        except Exception as e:
            click.echo('ERROR: {}'.format(e))
        else:
            for key in keys:
                click.echo('{:40} {}'.format(key.key, key.user))
147858
def _gcs_get_key_names(bucket, pattern):
  
  return [obj.metadata.name for obj in _gcs_get_keys(bucket, pattern)]