Update the settings for a slot.

    Change the settings for a slot without changing the stored secret.
    All settings not specified will be written with default values.
487660
def settings(ctx, slot, new_access_code, delete_access_code, enter, pacing,
             force):
    
    controller = ctx.obj['controller']

    if (new_access_code is not None) and delete_access_code:
        ctx.fail('--new-access-code conflicts with --delete-access-code.')

    if not controller.slot_status[slot - 1]:
        ctx.fail('Not possible to update settings on an empty slot.')

    if new_access_code is not None:
        if new_access_code == '':
            new_access_code = click.prompt(
                'Enter new access code', show_default=False, err=True)

        try:
            new_access_code = parse_access_code_hex(new_access_code)
        except Exception as e:
            ctx.fail('Failed to parse access code: ' + str(e))

    force or click.confirm(
        'Update the settings for slot {}? '
        'All existing settings will be overwritten.'.format(slot), abort=True,
        err=True)
    click.echo('Updating settings for slot {}...'.format(slot))

    if pacing is not None:
        pacing = int(pacing)

    try:
        controller.update_settings(slot, enter=enter, pacing=pacing)
    except YkpersError as e:
        _failed_to_write_msg(ctx, e)

    if new_access_code:
        try:
            controller.set_access_code(slot, new_access_code)
        except Exception as e:
            logger.error('Failed to set access code', exc_info=e)
            ctx.fail('Failed to set access code: ' + str(e))

    if delete_access_code:
        try:
            controller.delete_access_code(slot)
        except Exception as e:
            logger.error('Failed to delete access code', exc_info=e)
            ctx.fail('Failed to delete access code: ' + str(e))
291128
function SetSettings(settings) {
		try { CFG = TLS.Fill(settings, CFG); Dbg = CFG.Debug } 
		catch (error) { LG.IF(error); }
	}
1299031
def update_settings(instance_id, settings)
      params = {
        :instance_id => instance_id
      }

      instance = Models::RegistryInstance[params] || Models::RegistryInstance.new(params)
      instance.settings = settings
      instance.save
    end
505284
def set_settings(new_settings, options = {}, request_options = {})
      client.put(Protocol.settings_uri(name, options), new_settings.to_json, :write, request_options)
    end
576636
def update_settings(self, index, newvalues):
        
        path = make_path(index, "_settings")
        return self.conn._send_request('PUT', path, newvalues)
525167
def _reset_param(self, param):
        
        if param not in self._instance.CONFIG_PARAMS:
            raise ValueError("Cannot reset unknown parameter '{}'".format(param))
        setattr(self, param, self._instance.CONFIG_PARAMS[param])
146344
public function editSettings()
    {
        $this->setTitleEditSettings();
        $this->setBreadcrumbEditSettings();

        $this->setData('stores', $this->store->getList());
        $this->setData('credentials', $this->getCredentialSettings());
        $this->setData('handlers', $this->report_model->getHandlers());
        $this->setData('settings', $this->module->getSettings('ga_report'));

        $this->submitSettings();
        $this->outputEditSettings();
    }
268783
def set_config(self, config):
    
    if self.config is None:
      self.config = { }
    self.config.update(config_to_api_list(config))
991359
protected function resetSettings()
    {
        $this->controlAccess('module_edit');
        $this->module->setSettings('frontend', array());
        $this->redirect('', $this->text('Settings have been reset to default values'), 'success');
    }
1129998
def update_config(config):
    

    # Update the default config with whatever is in the passed config
    update(bigchaindb.config, update_types(config, bigchaindb.config))
    bigchaindb.config['CONFIGURED'] = True
307010
def pop(self, settings):
        
        if settings:
            for name in self.__slots__:
                self._set(name, settings.pop(name, UNSET))
141056
public static function _maybe_update_settings() {
		if ( ! empty( $_POST['menu-icons']['settings'] ) ) {
			check_admin_referer( self::UPDATE_KEY, self::UPDATE_KEY );

			$redirect_url = self::_update_settings( $_POST['menu-icons']['settings'] ); // Input var okay.
			wp_redirect( $redirect_url );
		} elseif ( ! empty( $_REQUEST[ self::RESET_KEY ] ) ) {
			check_admin_referer( self::RESET_KEY, self::RESET_KEY );
			wp_redirect( self::_reset_settings() );
		}
	}
959329
def update_credentials(self, aws_access_key_id, aws_secret_access_key):
        '''  '''
        self.aws_access_key_id = aws_access_key_id
        self.aws_secret_access_key = aws_secret_access_key
1294614
def update_default(self, new_default, respect_none=False):
        
        if new_default is not None:
            self.default = new_default
        elif new_default is None and respect_none:
            self.default = None
191239
def _set_value(self, slot_record):
    
    if slot_record.status == _SlotRecord.FILLED:
      self.filled = True
      self._filler_pipeline_key = _SlotRecord.filler.get_value_for_datastore(
          slot_record)
      self._fill_datetime = slot_record.fill_time
      self._value = slot_record.value
831174
public void setSlots(java.util.Collection<Slot> slots) {
        if (slots == null) {
            this.slots = null;
            return;
        }

        this.slots = new java.util.ArrayList<Slot>(slots);
    }
1012598
def update(self, settings):
        """"""
        self.settings.cache_clear()
        self._settings = settings
        log.info("Updated settings to %s", self._settings)
        self._update_disabled_plugins()