retrieve the jenks configuration object
973246
def _get_jenks_config():
    
    config_file = (get_configuration_file() or
                   os.path.expanduser(os.path.join("~", CONFIG_FILE_NAME)))

    if not os.path.exists(config_file):
        open(config_file, 'w').close()

    with open(config_file, 'r') as fh:
        return JenksData(
            yaml.load(fh.read()),
            write_method=generate_write_yaml_to_file(config_file)
        )
603699
def get(cls, key, default=None, separator='.', global_=False):
        
        # first check environnment variables
        # if we're not in global scope
        if not global_:
            ret = os.environ.get(key.upper().replace('.', '_'))
            if ret is not None:
                return ret

        # then check in local and global configuration unless global_=True
        scopes = ['global'] if global_ else ['local', 'global']
        for scope in scopes:
            ret = cls._get(scope, key, default, separator)
            if ret is not None and ret != default:
                return ret

        if ret is None or ret == default:
            return default
10098
function getOverrides() {
  const configPath = path.join(process.cwd(), "crafty.config.js");

  if (fs.existsSync(configPath)) {
    return require(configPath);
  }

  console.log(`No crafty.config.js found in '${process.cwd()}', proceeding...`);
  return {};
}
838793
def get_default_config(self):
        
        config = super(DropwizardCollector, self).get_default_config()
        config.update({
            'host':     '127.0.0.1',
            'port':     8081,
            'path':     'dropwizard',
        })
        return config
23905
def get_override_configuration(self):
        
        res = {}
        properties = self.__class__.properties
        for prop, entry in list(properties.items()):
            if entry.override:
                res[prop] = getattr(self, prop)
        return res
1322346
def _get_service_config(self):
        
        # Should work for windows, osx, and linux environments
        if not os.path.exists(self.config_path):
            try:
                os.makedirs(os.path.dirname(self.config_path))
            except OSError as exc:
                if exc.errno != errno.EEXIST:
                    raise

            return {}

        with open(self.config_path, 'r') as data:
            return json.load(data)
783320
def get_configuration_dict(self, secret_attrs=False):
        """"""
        cd = super(TreeCollectionsShard, self).get_configuration_dict(secret_attrs=secret_attrs)
        # "rename" some keys in the dict provided
        cd['number of collections'] = cd.pop('number of documents')
        cd['collections'] = cd.pop('documents')
        return cd
44469
def get_config():
    
    if session.config is None:
        path = session.default_config_path
        if os.path.isfile(path):
            logging.info("LOADING FROM: {}".format(path))
            session.config = load_config(path)
        else:
            session.config = Config()
            logging.info("using default session: {}, path does not exist: {}".format(session, path))
    else:
        logging.info("Using pre-loaded object: {}".format(session.config))
    return session.config
172470
def _configuration(self, *args, **kwargs):
        '''
        
        '''

        data = dict()
        self.db.open()
        for pkg in self.db.get(Package):
            configs = list()
            for pkg_cfg in self.db.get(PackageCfgFile, eq={'pkgid': pkg.id}):
                configs.append(pkg_cfg.path)
            data[pkg.name] = configs

        if not data:
            raise InspectorQueryException("No inspected configuration yet available.")

        return data
315545
function getConfig(config) {
  const logger = require('@blackbaud/skyux-logger');
  const minimist = require('minimist');
  const argv = minimist(process.argv.slice(2));
  require(`./${argv.watch ? 'watch' : 'test'}.karma.conf`)(config);
  let skyPagesConfig = require('../sky-pages/sky-pages.config').getSkyPagesConfig(argv._[0]);
  let testWebpackConfig = require('../webpack/test.webpack.config');
  const path = require('path');
  const pactServers = require('../../utils/pact-servers');

  skyPagesConfig.runtime.pactConfig = {};
  skyPagesConfig.runtime.pactConfig.providers = pactServers.getAllPactServers();
  skyPagesConfig.runtime.pactConfig.pactProxyServer = pactServers.getPactProxyServer();

  if (skyPagesConfig.skyux.pacts) {
    var i = 0;
    skyPagesConfig.skyux.pacts.forEach((pact) => {
      // set pact settings not specified in config file
      pact.log = pact.log || path.resolve(process.cwd(), 'logs', `pact-${pact.provider}.log`);
      pact.dir = pact.dir || path.resolve(process.cwd(), 'pacts');
      pact.host = pactServers.getPactServer(pact.provider).host;
      pact.port = pactServers.getPactServer(pact.provider).port;
      pact.pactFileWriteMode = pact.pactFileWriteMode || 'overwrite';

      i++;
    });
  } else {
    logger.error('No pact entry in configuration!');
  }

  config.set({
    frameworks: config.frameworks.concat('pact'),
    files: config.files.concat(path.resolve(process.cwd(), 'node_modules/@pact-foundation/pact-web',
    `pact-web.js`)),
    pact: skyPagesConfig.skyux.pacts,
    plugins: config.plugins.concat('@pact-foundation/karma-pact'),
    webpack: testWebpackConfig.getWebpackConfig(skyPagesConfig, argv)

  });

}
852292
function getDefaultConfig(defaultNames, packageName, obj) {
  for (let [objName, configName] of defaultNames) {
    obj[objName] = atom.config.get(`${packageName}.${configName}`);
  }
}
684794
def dump_config(self):
        

        conf = copy_config(self.config, self.mutable_config_keys)
        conf['state'] = {
            'cookiejar_cookies': list(self.cookies.cookiejar),
        }
        return conf
1061192
def config():
    ''''''
    if hasattr(current_app, 'settings_file'):
        log.info('Loaded configuration from %s', current_app.settings_file)

    log.info(white('Current configuration'))
    for key in sorted(current_app.config):
        if key.startswith('__') or not key.isupper():
            continue
        echo('{0}: {1}'.format(white(key), current_app.config[key]))
1248830
def iam_configuration(self):
        
        info = self._properties.get("iamConfiguration", {})
        return IAMConfiguration.from_api_repr(info, self)
688884
private void getConfigurationObject()
    {
        RDBMSPropertyReader reader = new RDBMSPropertyReader(externalProperties, kunderaMetadata
                .getApplicationMetadata().getPersistenceUnitMetadata(getPersistenceUnit()));
        this.conf = reader.load(getPersistenceUnit());
    }
1040114
def get_configuration(self):
        
        mapping = {}
        settings = self.get_settings()
        for service in self.context.getService():
            uid = api.get_uid(service)
            setting = settings.get(uid, {})
            config = {
                "hidden": setting.get("hidden", False),
            }
            mapping[uid] = config
        return mapping
64304
def OSXConfigurationProfile(self, data=None, subset=None):
        """"""
        return self.factory.get_object(jssobjects.OSXConfigurationProfile,
                                       data, subset)