Returns config value.

        See Also:
            :meth:`.set` and :attr:`.value`
498342
def get(self, fallback=not_set):
        

        envvar_value = self._get_envvar_value()
        if envvar_value is not not_set:
            return envvar_value

        if self.has_value:
            if self._value is not not_set:
                return self._value
            else:
                return copy.deepcopy(self.default)
        elif fallback is not not_set:
            return fallback
        elif self.required:
            raise RequiredValueMissing(name=self.name, item=self)
        return fallback
1345125
function(attr) {
        var attrConfig = Y_Node.ATTRS[attr],
            val;

        if (attrConfig && attrConfig.getter) {
            val = attrConfig.getter.call(this);
        } else if (Y_Node.re_aria.test(attr)) {
            val = this._node.getAttribute(attr, 2); 
        } else {
            val = Y_Node.DEFAULT_GETTER.apply(this, arguments);
        }

        return val;
    }
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
209146
def getConfig(self, key):
        
        if hasattr(self, key):
            return getattr(self, key)
        else:
            return False
594224
def get(config, key, default=None):
        

        if hasattr(config, key):
            return getattr(config, key)
        else:
            return default
568685
def config_value_items(self, sortkey = False):
        
        return ((k, getattr(self, k)) for k in self.config_value_keys(sortkey))
299663
def get_config_set(self, section, option):
		
		values = set()
		for cp, filename, fp in self.layers:
			filename = filename # pylint
			fp = fp # pylint
			if cp.has_option(section, option):
				values.add(cp.get(section, option))
		return values
100802
function ConfigValue(key, value) {
  this.name = ConfigValue.name;
  StoreError.apply(
    this, [null, 'invalid argument \'%s\' for CONFIG SET \'%s\'', value, key]);
}
1009413
def get_value(self):
        
        try:
            self.raw_value
        except (AttributeError, KeyError) as err:
            self._reraise_if_required(err)
            default_value = self.default_value
            if self.transform_default:
                return self.transform(default_value)
            return default_value
        else:
            # If setting is defined, load values of all subsettings.
            value = {}
            for key, subsetting in self.settings.items():
                value[key] = subsetting.get_value()
            return value
921965
def set(self, option, value):
        
        if self.config is None:
            self.config = {}
        self.config[option] = value
316632
def set_config_item(self, key, value):
        
        try:
            old_value = self.get_config_item(key)
        except KeyError:
            old_value = None

        # Get everything to unicode with python2
        if isinstance(value, str):
            value = value.decode()
        elif isinstance(value, list):
            for i in range(len(value)):
                if isinstance(value[i], str):
                    value[i] = value[i].decode()

        # Check if it's a list
        def set_key(key, value):
            self.clear_config_item(key)
            if isinstance(value, list):
                for entry in value:
                    if not _lxc.Container.set_config_item(self, key, entry):
                        return False
            else:
                _lxc.Container.set_config_item(self, key, value)

        set_key(key, value)
        new_value = self.get_config_item(key)

        # loglevel is special and won't match the string we set
        if key == "lxc.loglevel":
            new_value = value

        if (isinstance(value, unicode) and isinstance(new_value, unicode) and
                value == new_value):
            return True
        elif (isinstance(value, list) and isinstance(new_value, list) and
                set(value) == set(new_value)):
            return True
        elif (isinstance(value, unicode) and isinstance(new_value, list) and
                set([value]) == set(new_value)):
            return True
        elif old_value:
            set_key(key, old_value)
            return False
        else:
            self.clear_config_item(key)
            return False
702630
def value(self):
        
        if self.normalized:
            conf = self.conf.astype(np.float32)
            return conf / conf.sum(1).clip(min=1e-12)[:, None]
        else:
            return self.conf
703165
def config(key, value, local=True):
    
    option = local and '--local' or ''
    run('config %s "%s" "%s"' % (option, key, value))
1365438
def _get_config(self, host, port, unix_socket, auth, config_key):
        

        client = self._client(host, port, unix_socket, auth)
        if client is None:
            return None

        config_value = client.config_get(config_key)
        del client
        return config_value
834478
def config_(cls, key, default=None):
        
        return cls._app.config.get(key, default)
1194541
async def set_config(cls, name: str, value):
        
        return await cls._handler.set_config(name=[name], value=[value])
1119554
def get_attribute_at(config, target_path, key, default_value=None):
    
    for target in target_path:
        config = config[target]
    return config[key] if key in config else default_value