Get a configuration object for this type of YubiKey.
349950
def init_config(self, **kw):
        
        return YubiKeyConfigUSBHID(ykver=self.version_num(), \
                                       capabilities = self.capabilities, \
                                       **kw)
630356
def _get_key_value_config(self):
        """"""
        for rp in self._remote_providers:
            val = self._get_remote_config(rp)
            self._kvstore = val
            return None

        raise errors.RemoteConfigError("No Files Found")
594224
def get(config, key, default=None):
        

        if hasattr(config, key):
            return getattr(config, key)
        else:
            return default
1310681
def get(self, namespace, key):
        """"""
        cfg = self.dbconfig.get(key, namespace, as_object=True)
        return self.make_response({
            'message': None,
            'config': cfg
        })
688884
private void getConfigurationObject()
    {
        RDBMSPropertyReader reader = new RDBMSPropertyReader(externalProperties, kunderaMetadata
                .getApplicationMetadata().getPersistenceUnitMetadata(getPersistenceUnit()));
        this.conf = reader.load(getPersistenceUnit());
    }
1078938
def get_configuration(self, uri):
        '''
        
        '''

        req_headers = {
            'Accept': 'application/vnd.onshape.v1+json',
            'Content-Type': 'application/json'
        }
        return self._api.request('get', '/api/partstudios/d/' + uri["did"] + '/' + uri["wvm_type"] + '/' + uri["wvm"] + '/e/' + uri["eid"] + '/configuration', headers=req_headers)
361054
def get_version():
    """"""

    with open('yubico/yubico_version.py', 'r') as f:
        match = VERSION_PATTERN.search(f.read())
        return match.group(1)
871363
def get_key(cls, key):
        ""
        return cls.get().get(key, cls.DEFAULT_CONFIG.get(key,None))
484323
def get_instance(in_memory=False, config_path=None, config_name=None):
  
  global __conf

  if __conf is None:
    __conf = Configuration(in_memory=in_memory, custom_cfg_path=config_path, config_name=config_name)

  return __conf
728585
def fetch(self, ui_version=values.unset):
        
        params = values.of({'UiVersion': ui_version, })

        payload = self._version.fetch(
            'GET',
            self._uri,
            params=params,
        )

        return ConfigurationInstance(self._version, payload, )
560575
function() {
		if(Bitovi.OSS.Configuration.configuration === null) {
			Bitovi.OSS.Configuration.configuration = $.ajax({
				url: Bitovi.URL.BUILDER_DATA,
				dataType: 'jsonp'
			});
		}

		return Bitovi.OSS.Configuration.configuration;
	}
460412
def get_config_item(self, key):
        
        value = _lxc.Container.get_config_item(self, key)

        if value is False:
            return False
        elif value.endswith("\n"):
            return value.rstrip("\n").split("\n")
        else:
            return value
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
598166
def getConfigRoot(cls, create = False):
        
        try:
            return manager.gettree(getattr(cls, 'configkey'), create)
        except AttributeError:
            return None
785089
def getConfig(option, serverEndpoint=ServerEndpoint, verbose=Verbose, tikaServerJar=TikaServerJar, responseMimeType='application/json',
              services={'mime-types': '/mime-types', 'detectors': '/detectors', 'parsers': '/parsers/details'}):
    '''
    
    '''
    if option not in services:
        die('config option must be one of mime-types, detectors, or parsers')
    service = services[option]
    status, response = callServer('get', serverEndpoint, service, None, {'Accept': responseMimeType}, verbose, tikaServerJar)
    return (status, response)
95206
def get_config(config, default_config):
    ''''''
    if not config:
        logging.warning('Using default config: %s', default_config)
        config = default_config

    try:
        with open(config, 'r') as config_file:
            return yaml.load(config_file)
    except (yaml.reader.ReaderError,
            yaml.parser.ParserError,
            yaml.scanner.ScannerError) as e:
        raise ConfigError('Invalid yaml file: \n %s' % str(e))
774826
private Dictionary<String,String> getConfiguration() {
        Dictionary<String,String> config = new Hashtable<String,String>();
        for (ConfigKey key : ConfigKey.values()) {
            String value = getConfiguration(key);
            if (value != null) {
                config.put(key.getKeyValue(),value);
            }
        }
        String jolokiaId = NetworkUtil.replaceExpression(config.get(ConfigKey.AGENT_ID.getKeyValue()));
        if (jolokiaId == null) {
            config.put(ConfigKey.AGENT_ID.getKeyValue(),
                       NetworkUtil.getAgentId(hashCode(),"osgi"));
        }
        config.put(ConfigKey.AGENT_TYPE.getKeyValue(),"osgi");
        return config;
    }