Get the possible configuration files accepted by oslo.config

    This also includes the deprecated ones
428700
def _get_config_files():
    
    # default files
    conf_files = cfg.find_config_files(project='monasca',
                                       prog='monasca-persister')
    # deprecated config files (only used if standard config files are not there)
    if len(conf_files) == 0:
        old_conf_files = cfg.find_config_files(project='monasca',
                                               prog='persister')
        if len(old_conf_files) > 0:
            LOG.warning('Found deprecated old location "{}" '
                        'of main configuration file'.format(old_conf_files))
            conf_files += old_conf_files
    return conf_files
1355016
def get_yaml_config(config_path):
    
    config_path = os.path.expanduser(config_path)
    if not os.path.isfile(config_path):
        raise IpaUtilsException(
            'Config file not found: %s' % config_path
        )

    with open(config_path, 'r') as f:
        config = yaml.safe_load(f)
    return config
1012952
def _get_existing_conf(config):
    
    try:
        with open(os.path.join(config, 'local.conf'), 'r') as f:
            lines = [line for line in f.readlines()
                     if not (line.startswith('service_id') or line.startswith('client_secret'))]
    except IOError:
        lines = []
    return lines
639463
def find_home_config_files(filetype=['json', 'yaml']):
    """"""
    configs = []

    yaml_config = os.path.expanduser('~/.vcspull.yaml')
    has_yaml_config = os.path.exists(yaml_config)
    json_config = os.path.expanduser('~/.vcspull.json')
    has_json_config = os.path.exists(json_config)

    if not has_yaml_config and not has_json_config:
        log.debug(
            'No config file found. Create a .vcspull.yaml or .vcspull.json'
            ' in your $HOME directory. http://vcspull.git-pull.com for a'
            ' quickstart.'
        )
    else:
        if sum(filter(None, [has_json_config, has_yaml_config])) > int(1):
            raise exc.MultipleConfigWarning()
        if has_yaml_config:
            configs.append(yaml_config)
        if has_json_config:
            configs.append(json_config)

    return configs
253394
def config_files(override)
      # Adjust verbosity quickly
      Bunto.logger.adjust_verbosity(
        :quiet   => quiet?(override),
        :verbose => verbose?(override)
      )

      # Get configuration from <source>/_config.yml or <source>/<config_file>
      config_files = override.delete("config")
      if config_files.to_s.empty?
        default = %w(yml yaml).find(-> { "yml" }) do |ext|
          File.exist?(Bunto.sanitized_path(source(override), "_config.#{ext}"))
        end
        config_files = Bunto.sanitized_path(source(override), "_config.#{default}")
        @default_config_file = true
      end
      config_files = [config_files] unless config_files.is_a? Array
      config_files
    end
874730
function getReleaseConfig() {
  var configFileName = path.join(__dirname, '..', 'package.json');

  return fs.readFileAsync(configFileName, 'utf-8')
    .then(function (data) {
      var conf;
      try {
        conf = JSON.parse(data);
        if (conf && conf.thaliInstall) {
          return conf.thaliInstall;
        }
        return Promise.reject('Configuration error!');
      }
      catch (err) {
        return Promise.reject(new Error(err));
      }
    });
}
69232
function getConfigPath(configPaths) {
  let conf = null;

  // Try all config paths and return for the first found one
  some(configPaths, configPath => {
    if (!configPath) return;

    // Compile config using environment variables
    const compiledConfigPath = template(configPath)(process.env);

    let resolvedConfigPath = resolve(process.cwd(), compiledConfigPath);
    const resolvedName = fileExists(resolvedConfigPath);

    if (resolvedConfigPath && resolvedName) {
      conf = resolvedName;
    }

    return conf;
  });

  return conf;
}
145040
def get_global_compatibility_level(self):
        
        res = requests.get(self._url('/config'), headers=HEADERS)
        raise_if_failed(res)
        return res.json()['compatibility']
481082
def get_config(config_file):
    """"""
    config_path = os.path.abspath(config_file)

    try:
        with open(config_path, 'r') as data:
            config = yaml.safe_load(data)
    except IOError as exc:
        sys.exit(str(exc))

    return config
135610
function getUsageOptions() {
  var configData = this.config.data;
  if (configData.usage && configData.usage.options) {
    return configData.usage.options;
  }
  return {};
}
487034
def get_configs(cls):
        
        import docido_sdk.config
        http_config = docido_sdk.config.get('http') or {}
        session_config = http_config.get('session') or {}
        rate_limits = session_config.get('rate_limit') or {}
        return rate_limits
248668
def parse_config(file_name='/usr/local/etc/pkg.conf'):
    '''
    
    '''
    ret = {}
    if not os.path.isfile(file_name):
        return 'Unable to find {0} on file system'.format(file_name)

    with salt.utils.files.fopen(file_name) as ifile:
        for line in ifile:
            line = salt.utils.stringutils.to_unicode(line)
            if line.startswith('#') or line.startswith('\n'):
                pass
            else:
                key, value = line.split('\t')
                ret[key] = value
    ret['config_file'] = file_name
    return ret
798452
private File[] resolveConfigFiles(File base, Map<String, Object> override) {
        //system properties
        //-Dconfig=config.json -> override
        //Override
        if (override != null) {
            String configFilesString = (String) override.remove("config");
            if (StringUtils.isNotBlank(configFilesString)) {
                log.info("Using config files: {}", configFilesString);

                String[] strings = StringUtils.split(configFilesString, ',');
                File[] files = new File[strings.length];
                for (int i = 0; i < strings.length; i++) {
                    files[i] = new File(base, strings[i]);
                }
                return files;
            }
        }

        //default
        useDefaultConfigFiles = true;
        return base.listFiles(DEFAULT_CONFIG_FILES_FILTER);
    }
1191918
def config_for(environment=:development)
      if self.config.present?
        env_config = self.config[environment.to_s]
      else
        env_config = {
          'host' => ENV['RIAK_HOST'],
          'http_port' => ENV['RIAK_HTTP_PORT'],
          'pb_port' => ENV['RIAK_PB_PORT']
        }
      end
      env_config
    end
537967
function getConfig(api /*: any */) /*: BabelCoreOptions */ {
  api.cache.never();

  return {
    babelrc: false,
    presets: presets.map(preset => require.resolve(preset)),
    plugins: plugins.map(plugin => require.resolve(plugin)),
  };
}
113690
function config() {
  if(!process.env.PLATFORM_PROJECT) {
    throw Error('This is not running on platform.sh');
  }

  return {
    application: read_base64_json('PLATFORM_APPLICATION'),
    relationships: read_base64_json('PLATFORM_RELATIONSHIPS'),
    variables: read_base64_json('PLATFORM_VARIABLES'),
    application_name: process.env.PLATFORM_APPLICATION_NAME,
    app_dir: process.env.PLATFORM_APP_DIR,
    environment: process.env.PLATFORM_ENVIRONMENT,
    project: process.env.PLATFORM_PROJECT,
    routes: read_base64_json('PLATFORM_ROUTES'),
    tree_id: process.env.PLATFORM_TREE_ID,
    project_entropy: process.env.PLATFORM_PROJECT_ENTROPY,
    branch: process.env.PLATFORM_BRANCH,
    document_root: process.env.PLATFORM_DOCUMENT_ROOT,
    port: process.env.PORT,
    omp_num_threads: num_of_cpus()
  };
}
654418
def detect_config(self):
        """"""
        default_files = ("config.json", "config.yml")
        for file_ in default_files:
            if os.path.exists(file_):
                return file_