Updates the corresponding list store of a changed config value

        :param ConfigModel config_m: The config model that has been changed
        :param str config_key: The config key who's value has been changed
14715
def update_config_value(self, config_m, config_key):
        
        config_value = config_m.get_current_config_value(config_key)
        if config_m is self.core_config_model:
            list_store = self.core_list_store
        elif config_m is self.gui_config_model:
            list_store = self.gui_list_store
        else:
            return
        self._update_list_store_entry(list_store, config_key, config_value)
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))
170810
def config_keys(self, sortkey = False):
        
        if sortkey:
            items = sorted(self.items())
        else:
            items = self.items()
        for k,v in items:
            if isinstance(v, ConfigTree):
                for k2 in v.config_keys(sortkey):
                    yield k + '.' + k2
            else:
                yield k
1355981
def changememokey(ctx, key, account):
    
    pprint(ctx.blockchain.update_memo_key(key, account=account))
894286
def update_config(self, key, value):
        
        dataset = self._top._config.dataset
        session = object_session(self._top._config)
        logger.debug(
            'Updating VarDictGroup config. dataset: {}, type: {}, key: {}, value: {}'.format(
                dataset, self._top._type, key, value))

        if not self._parent._config:
            self._parent.update_config()

        # create or update group config
        self._config, created = get_or_create(
            session, Config,
            d_vid=dataset.vid, type=self._top._type,
            parent=self._parent._config, group=self._key,
            key=self._key,dataset=dataset)
        self._top._add_valid(self._config)

        # create or update value config
        config, created = get_or_create(
            session, Config, parent=self._config, d_vid=dataset.vid,
            type=self._top._type, key=key,dataset=dataset)

        if config.value != value:
            # sync db value with term value.
            config.value = value
            session.merge(config)
            session.commit()
            logger.debug(
                'Config bound to the VarDictGroup key updated. config: {}'.format(config))
        self._top._add_valid(config)
787229
def config(config_dict: typing.Mapping) -> Config:
    
    logger.debug(f"Updating with {config_dict}")
    _cfg.update(config_dict)
    return _cfg
1361661
def _update(self):
        
        with self._lock:
            if getmtime(self._filename) > self._last_modified:
                self._last_modified = getmtime(self._filename)
                self._book = ConfigParser(default_section='format')
                self._book.read(self._filename)
385555
def update(self, *args, **kwargs):
        
        d = {}
        d.update(*args, **kwargs)
        for key, value in d.items():
            self[key] = value
992388
def update1(self, key: str, data: np.ndarray, size: int) -> None:
        
        print(data)
        if key in self.get_keys():
            self.data[key][data[0]] = data
        else:
            newdata = np.zeros((size, 6))
            newdata[data[0]] = data
            self.data[key] = newdata
554773
def update_config(self):
        
        dataset = self._top._config.dataset
        session = object_session(self._top._config)
        logger.debug(
            'Updating group config. dataset: {}, type: {}, key: {}'.format(dataset.vid, self._top._type, self._key))

        self._config, created = _get_config_instance(
            self, session,
            parent_id=self._parent._config.id, d_vid=dataset.vid,
            group=self._key, key=self._key, type=self._top._type, dataset = dataset)
        if created:
            self._top._cached_configs[self._get_path()] = self._config
        self._top._add_valid(self._config)

        if created:
            logger.debug(
                'New group config created and linked. config: {}'.format(self._config))
        else:
            logger.debug(
                'Existing group config linked. config: {}'.format(self._config))
431177
def set_config(self, key, value):
        

        keyname = "config:" + key

        self.kvstore.set(keyname, value)
925968
def update_config(cls, config_file, config):
        
        need_save = False
        # delete old env key
        if 'api' in config and 'env' in config['api']:
            del config['api']['env']
            need_save = True
        # convert old ssh_key configuration entry
        ssh_key = config.get('ssh_key')
        sshkeys = config.get('sshkey')
        if ssh_key and not sshkeys:
            config.update({'sshkey': [ssh_key]})
            need_save = True
        elif ssh_key and sshkeys:
            config.update({'sshkey': sshkeys.append(ssh_key)})
            need_save = True
        # remove old value
        if ssh_key:
            del config['ssh_key']
            need_save = True

        # save to disk
        if need_save:
            cls.save(config_file, config)
750892
public synchronized void updateMasterConf(PropertyKey key, @Nullable String value) {
    mMasters.forEach(master -> master.updateConf(key, value));
  }
590097
def changes(new_cmp_dict, old_cmp_dict, id_column, columns):
    

    update_ldict = []
    same_keys = set(new_cmp_dict).intersection(set(old_cmp_dict))
    for same_key in same_keys:
        # Get the Union of the set of keys
        # for both dictionaries to account
        # for missing keys
        old_dict = old_cmp_dict[same_key]
        new_dict = new_cmp_dict[same_key]
        dict_keys = set(old_dict).intersection(set(new_dict))

        update_dict = {}
        for dict_key in columns:
            old_val = old_dict.get(dict_key, 'NaN')
            new_val = new_dict.get(dict_key, 'NaN')
            if old_val != new_val and new_val != 'NaN':
                if id_column!=None:
                    try:
                        update_dict[id_column] = old_dict[id_column]
                    except KeyError:
                        print("Input Dictionary 'old_cmp_dict' must have ID column")
                update_dict[dict_key] = new_val
        if update_dict:
            update_ldict.append(update_dict)
    return update_ldict
98774
protected final void set(M config) {
        ArrayList<WeakReference<ConfigListener<M,F>>> iterateOver;
        synchronized (this) {
            M old = instance.get();
            if (old == config || (old != null && old.equals(config))) {
                return;
            }

            instance.set(config);
            lastUpdateTimestamp.set(clock.millis());
            listeners.removeIf(ref -> ref.get() == null);
            iterateOver = new ArrayList<>(listeners);
        }
        iterateOver.forEach(ref -> {
            ConfigListener<M,F> listener = ref.get();
            if (listener != null) {
                try {
                    listener.onConfigChange(config);
                } catch (Exception ignore) {
                    // Ignored... TODO: At least log?
                }
            }
        });
    }
1289612
def change_key(self, key):
        

        services = {}
        for service_name in self.list_services():
            services[service_name] = self.get_service(service_name)

        orgs = {}
        for org_name in self.list_orgs():
            orgs[org_name] = self.get_org(org_name)

        self.key = key

        if orgs:
            for org_name, org_config in list(orgs.items()):
                self.set_org(org_config)

        if services:
            for service_name, service_config in list(services.items()):
                self.set_service(service_name, service_config)

        self._convert_connected_app()
437461
def _key_changed(self, client, cnxn_id, entry, data=None):
        
        key = self._fix_key(entry.key)[len(self.GCONF_DIR):]
        value = self._get_value(entry.value, self.DEFAULTS[key])

        self.emit('conf-changed', key, value)