/v1/startupscript/update
        POST - account
        Update an existing startup script

        Link: https://www.vultr.com/api/#startupscript_update
967817
def update(self, scriptid, params=None):
        ''' 
        '''
        params = update_params(params, {'SCRIPTID': scriptid})
        return self.request('/v1/startupscript/update', params, 'POST')
655382
def script_update(self, script: str, params: Union[dict, None], doc_id: str):
        
        body = {
            'script': {
                'source': script,
                'lang': 'painless'
            }
        }
        if params is not None:
            body['script']['params'] = params
        self.instance.update(self.index, self.doc_type, doc_id, body=body)
1030494
def update
      @script_extension.user_id = current_user.id
      @script_extension.org_id = current_user.org_id
      if @script_extension.update(script_extension_params)
        redirect_to script_extensions_url, notice: 'Extension was successfully updated.'
        else
          render :edit
      end
    end
1119304
function update() {
		var f = self.fm.getSelected(0);
		reset();

		self._hash = f.hash;
		self.title.text(f.name);
		self.win.addClass(self.fm.view.mime2class(f.mime));
		self.name.text(f.name);
		self.kind.text(self.fm.view.mime2kind(f.link ? 'symlink' : f.mime)); 
		self.size.text(self.fm.view.formatSize(f.size));
		self.date.text(self.fm.i18n('Modified')+': '+self.fm.view.formatDate(f.date));
		f.dim && self.add.append('<span>'+f.dim+' px</span>').show();
		f.tmb && self.ico.css('background', 'url("'+f.tmb+'") 0 0 no-repeat');
		if (f.url) {
			self.url.text(f.url).attr('href', f.url).show();
			for (var i in self.plugins) {
				if (self.plugins[i].test && self.plugins[i].test(f.mime, self.mimes, f.name)) {
					self.plugins[i].show(self, f);
					return;
				}
			}
		} else {
			self.url.hide();
		}
		
		self.win.css({
			width  : '420px',
			height : 'auto'
		});
	}
1368576
def update(self, password=values.unset):
        
        data = values.of({'Password': password, })

        payload = self._version.update(
            'POST',
            self._uri,
            data=data,
        )

        return CredentialInstance(
            self._version,
            payload,
            account_sid=self._solution['account_sid'],
            credential_list_sid=self._solution['credential_list_sid'],
            sid=self._solution['sid'],
        )
1271378
def update(self, **kwargs):
        
        data = self._generate_input_dict(**kwargs)
        self.load(self.client.put('/'.join(self.url.split('/')[:-1]) + 's', data=data))
        return self
1141588
@RequestMapping(value = "{accountId}/update", method = RequestMethod.PUT)
    public Account updateAccount(@PathVariable ID accountId, @RequestBody @Valid AccountInput input) {
        return accountService.updateAccount(accountId, input);
    }
1186220
def startup_script(self, startup_script):
        

        try:
            startup_script_path = os.path.join(self.working_dir, 'startup.vpc')
            with open(startup_script_path, "w+", encoding='utf-8') as f:
                if startup_script is None:
                    f.write('')
                else:
                    startup_script = startup_script.replace("%h", self._name)
                    f.write(startup_script)
        except OSError as e:
            raise VPCSError('Cannot write the startup script file "{}": {}'.format(startup_script_path, e))
1042900
function update(form) {
      // refuse to work with invalid data
      if (!vm.user._id || form && !form.$valid) {
        return;
      }

      UserService.update(vm.user)
        .then(updateUserSuccess)
        .catch(updateUserCatch);

      function updateUserSuccess(updatedUser) {
        // update the display name after successful save
        vm.displayName = updatedUser.name;
        Toast.show({text: 'User ' + updatedUser.name + ' updated'});
        if (form) {
          form.$setPristine();
        }
      }

      function updateUserCatch(err) {
        Toast.show({
          type: 'warn',
          text: 'Error while updating user ' + vm.displayName,
          link: {state: $state.$current, params: $stateParams}
        });

        if (form && err) {
          form.setResponseErrors(err.data);
        }
      }
    }
21022
def update(self, uid):
        '''
        
        '''
        if self.userinfo.role[1] >= '3':
            pass
        else:
            return False
        post_data = self.get_post_data()

        post_data['user_name'] = self.get_current_user()

        if self.is_p:
            if MLink.update(uid, post_data):
                output = {
                    'addinfo ': 1,
                }
            else:
                output = {
                    'addinfo ': 0,
                }
            return json.dump(output, self)
        else:
            if MLink.update(uid, post_data):
                self.redirect('/link/list')
343259
def update(self, params=None, client=c):
        
        uri = self.parent.uri
        if not params or not self.res:
            self.get_params()
            return
        d = self.payload
        for k, v in params.items():
            m = d["currentConfiguration"][self.parameter_map[k]]["message"]
            if isinstance(v, bool) or isinstance(v, str):
                m["value"] = v
            else:
                try:
                    m["expression"] = str(v)
                except KeyError:
                    m["value"] = str(v)

        res = client.update_configuration(uri.did, uri.wvm, uri.eid, json.dumps(d))

        # If it was a good request, update config to be consistent with online.
        if res.status_code == 200:
            self.res = res
1274013
def startup(name):
    '''
    
    '''
    ret = {'name': name,
           'changes': {},
           'result': None,
           'comment': ''}

    if __opts__['test']:
        ret['comment'] = 'Starting up local node'
        return ret

    __salt__['trafficserver.startup']()

    ret['result'] = True
    ret['comment'] = 'Starting up local node'
    return ret
1108106
def profile_update_schema(profile):
        

        # add new "autoclear" field
        if profile.get('autoclear') is None:
            print(
                '{}{}Profile Update: Adding new "autoclear" parameter.'.format(
                    c.Style.BRIGHT, c.Fore.YELLOW
                )
            )
            profile['autoclear'] = True

        # add new "data_type" field
        for validation in profile.get('validations') or []:
            if validation.get('data_type') is None:
                print(
                    '{}{}Profile Update: Adding new "data_type" parameter.'.format(
                        c.Style.BRIGHT, c.Fore.YELLOW
                    )
                )
                validation['data_type'] = 'redis'

        # remove "script" parameter from profile
        if profile.get('install_json') is not None and profile.get('script') is not None:
            print(
                '{}{}Removing deprecated "script" parameter.'.format(c.Style.BRIGHT, c.Fore.YELLOW)
            )
            profile.pop('script')
800730
public void startUpdate(String targetId) throws IOException {
        startChangesIfNecessary();
        inUpdate = true;
        ResponseWriter writer = getWrapped();
        writer.startElement("update", null);
        writer.writeAttribute("id", targetId, null);
        writer.startCDATA();
    }
26443
function (options, type) {
        // update must have options
        if (!_.isObject(options)) { return; }
        // validate type parameter and/or choose default from existing type.
        if (!RequestAuth.isValidType(type)) { type = this.type; }

        var parameters = this[type];

        // in case the type holder is not created, we create one and send the population variables
        if (!VariableList.isVariableList(parameters)) {
            // @todo optimise the handling of legacy object type auth parameters
            parameters = this[type] = new VariableList(this);
            parameters._postman_requestAuthType = type;
        }

        // we simply assimilate the new options either it is an array or an object
        if (_.isArray(options) || VariableList.isVariableList(options)) {
            parameters.assimilate(options);
        }
        else {
            parameters.syncFromObject(options, false, false); // params: no need to track and no need to prune
        }
    }
1200186
func (c *Client) UpdateStartupScript(script StartupScript) error {
	values := url.Values{
		"SCRIPTID": {script.ID},
	}
	if script.Name != "" {
		values.Add("name", script.Name)
	}
	if script.Content != "" {
		values.Add("script", script.Content)
	}

	if err := c.post(`startupscript/update`, values, nil); err != nil {
		return err
	}
	return nil
}
74630
def update_subscription(netid, action, subscription_code, data_field=None):
    
    url = '/nws/v1/subscription.json'
    action = {
        'uwNetID': netid,
        'action': action,
        'subscriptionCode': str(subscription_code)
    }

    if isinstance(data_field, tuple) and len(data_field) == 2:
        action[data_field[0]] = str(data_field[1])

    body = {'actionList': [action]}
    response = post_resource(url, json.dumps(body))
    return _json_to_subscriptions(response)