Returns a printable version of the configuration, as a list of
        key=value pairs, one per line.
14470
def toDebugString(self):
        
        if self._jconf is not None:
            return self._jconf.toDebugString()
        else:
            return '\n'.join('%s=%s' % (k, v) for k, v in self._conf.items())
1249153
def get_def_conf():
    ''''''
    ret = dict()
    for k,v in defConf.items():
        ret[k] = v[0]
    return ret
5075
def get_kws_plt(self):
        """"""
        kws_plt = {}
        for key_plt in self.keys_plt:
            key_val = getattr(self, key_plt, None)
            if key_val is not None:
                kws_plt[key_plt] = key_val
            elif key_plt in self.kws:
                kws_plt[key_plt] = self.kws[key_plt]
        return kws_plt
1257804
@SuppressWarnings("unchecked")
    public Dictionary<String, String> getConfigurationProperties(Dictionary<String, String> dictionary, boolean returnCopy)
    {
        if (returnCopy)
            dictionary = putAll(dictionary, null);
        if (dictionary == null)
            dictionary = new Hashtable<String, String>();
        try {
            String servicePid = this.getServicePid();
            if (servicePid != null)
            {
                ServiceReference caRef = context.getServiceReference(ConfigurationAdmin.class.getName());
                if (caRef != null)
                {
                    ConfigurationAdmin configAdmin = (ConfigurationAdmin)context.getService(caRef);
                    Configuration config = configAdmin.getConfiguration(servicePid);

                    Dictionary<String, String> configProperties = config.getProperties();
                    dictionary = putAll(configProperties, dictionary);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return dictionary;
    }
710138
def get(self):
        """"""
        return {k:v for k,v in list(self.options.items()) if k in self._allowed_layout}
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
        }
815294
def config_value_keys(self, sortkey = False):
        
        if sortkey:
            items = sorted(self.items())
        else:
            items = self.items()
        return (k for k,v in items if not isinstance(v,ConfigTree))
986943
def pp_options_list(keys, width=80, _print=False):
    

    from textwrap import wrap
    from itertools import groupby

    def pp(name, ks):
        pfx = '- ' + name + '.[' if name else ''
        ls = wrap(
            ', '.join(ks),
            width,
            initial_indent=pfx,
            subsequent_indent='  ',
            break_long_words=False,
        )
        if ls and ls[-1] and name:
            ls[-1] = ls[-1] + ']'
        return ls

    ls = []
    singles = [x for x in sorted(keys) if x.find('.') < 0]
    if singles:
        ls += pp('', singles)
    keys = [x for x in keys if x.find('.') >= 0]

    for k, g in groupby(sorted(keys), lambda x: x[: x.rfind('.')]):
        ks = [x[len(k) + 1 :] for x in list(g)]
        ls += pp(k, ks)
    s = '\n'.join(ls)
    if _print:
        print(s)
    else:
        return s
1243304
def config():
    # type: () -> dict[str, Any]
    
    out = shell.run(
        'git config --list',
        capture=True,
        never_pretend=True
    ).stdout.strip()

    result = {}
    for line in out.splitlines():
        name, value = line.split('=', 1)
        result[name.strip()] = value.strip()

    return result
148753
private Optional<String> get(String key, Set<String> processingKeys) {

        for (ConfigurationSource configurationSource : config.getConfigurationSources()) {

            Optional<String> value = configurationSource.get(key);

            if (value.isPresent()) {

                return Optional.of(interpolateString(
                        key, ConfigurationDecoderUtils.decodeConfigValueIfEncoded(key, value.get()), processingKeys));
            }
        }

        return Optional.empty();
    }
1097724
def config():
    '''
    
    '''
    config = get_config()
    print('Client version: {0}'.format(click.style(__version__, bold=True)))
    print('API endpoint: {0}'.format(click.style(str(config.endpoint), bold=True)))
    print('API version: {0}'.format(click.style(config.version, bold=True)))
    print('Access key: "{0}"'.format(click.style(config.access_key, bold=True)))
    masked_skey = config.secret_key[:6] + ('*' * 24) + config.secret_key[-10:]
    print('Secret key: "{0}"'.format(click.style(masked_skey, bold=True)))
    print('Signature hash type: {0}'.format(
        click.style(config.hash_type, bold=True)))
    print('Skip SSL certificate validation? {0}'.format(
        click.style(str(config.skip_sslcert_validation), bold=True)))
811244
def to_configs(self):
        
        config_obj = reda.configs.configManager.ConfigManager()
        config_obj.add_to_configs(self.data[['a', 'b', 'm', 'n']].values)
        return config_obj
209062
def render_configuration(self, configuration=None):
        
        if configuration is None:
            configuration = self.environment

        if isinstance(configuration, dict):
            return {k: self.render_configuration(v) for k, v in configuration.items()}
        elif isinstance(configuration, list):
            return [self.render_configuration(x) for x in configuration]
        elif isinstance(configuration, Variable):
            return configuration.resolve(self.parameters)
        else:
            return configuration
1154693
def get_config(self):
        
        # Fill this dict with config data
        return {
            'hash_name': self.hash_name,
            'dim': self.dim,
            'bin_width': self.bin_width,
            'projection_count': self.projection_count,
            'normals': self.normals
        }
744336
def List(self):
        
        print()
        for key in list(self.keys()):
            print(key,'=',self[key])
        print()
593361
def keys
      map { |line| line.kind_of?(Array) ? line.first.key : line.key }
    end
273938
def read_config_multiline_options(obj: Any,
                                  parser: ConfigParser,
                                  section: str,
                                  options: Iterable[str]) -> None:
    
    for o in options:
        setattr(obj, o, get_config_multiline_option(parser, section, o))