Use this API to update pqpolicy.
490970
public static base_response update(nitro_service client, pqpolicy resource) throws Exception {
		pqpolicy updateresource = new pqpolicy();
		updateresource.policyname = resource.policyname;
		updateresource.weight = resource.weight;
		updateresource.qdepth = resource.qdepth;
		updateresource.polqdepth = resource.polqdepth;
		return updateresource.update_resource(client);
	}
240019
public static base_response update(nitro_service client, scpolicy resource) throws Exception {
		scpolicy updateresource = new scpolicy();
		updateresource.name = resource.name;
		updateresource.url = resource.url;
		updateresource.rule = resource.rule;
		updateresource.delay = resource.delay;
		updateresource.maxconn = resource.maxconn;
		updateresource.action = resource.action;
		updateresource.altcontentsvcname = resource.altcontentsvcname;
		updateresource.altcontentpath = resource.altcontentpath;
		return updateresource.update_resource(client);
	}
158730
public Optional<AlertPolicy> update(AlertPolicy policy)
    {
        return HTTP.PUT(String.format("/v2/alerts_policies/%d.json", policy.getId()), policy, ALERT_POLICY);
    }
963288
def update(self):
        """"""
        # Reset stats
        self.reset()

        # Return psutil version as a tuple
        if self.input_method == 'local':
            # psutil version only available in local
            try:
                self.stats = psutil_version_info
            except NameError:
                pass
        else:
            pass

        return self.stats
1122617
def update_cb(self, context, t, idx, userdata):
        """"""

        if t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK == PA_SUBSCRIPTION_EVENT_SERVER:
            pa_operation_unref(
                pa_context_get_server_info(context, self._server_info_cb, None))

        self.request_update(context)
903750
def update(self, *args, **kwargs):
        """"""
        self._call_helper("Updating", self.real.update, *args, **kwargs)
250821
def update(self):
        """"""
        ret = True
        fields = self.depopulate(True)
        q = self.query
        q.set_fields(fields)

        pk = self.pk
        if pk:
            q.is_field(self.schema.pk.name, pk)

        else:
            raise ValueError("You cannot update without a primary key")

        if q.update():
            fields = q.fields
            self._populate(fields)

        else:
            ret = False

        return ret
531822
public function updateApiURL()
    {
        $this->apiURL  = $this->getEvidenceURL();
        $rowIdentifier = $this->getRecordID();
        if (empty($rowIdentifier)) {
            $rowIdentifier = $this->getRecordCode();
            if (empty($rowIdentifier)) {
                $rowIdentifier = $this->getExternalID();
            }
        }
        if (!empty($rowIdentifier)) {
            $this->apiURL .= '/'.self::urlEncode($rowIdentifier);
        }
        $this->apiURL .= '.'.$this->format;
    }
659028
def update_records(self, headers, zoneID, updateRecords):
        """"""
        IP = requests.get(self.GET_EXT_IP_URL).text
        message = True
        errorsRecords = []
        sucessRecords = []
        for record in updateRecords:
            updateEndpoint = '/' + zoneID + '/dns_records/' + record[0]
            updateUrl = self.BASE_URL + updateEndpoint
            data = json.dumps({
                'id': zoneID,
                'type': record[2],
                'name': record[1],
                'content': IP,
                'proxied': record[4]
                })
            if record[3] != IP and record[2] == 'A':
                result = requests.put(updateUrl,
                    headers=headers, data=data).json()
                if result['success'] == True:
                    sucessRecords.append(record[1])
                else:
                    errorsRecords.append(record[1])
                if errorsRecords != []:
                    message = ("There was an error updating these records: "
                        + str(errorsRecords) + " , the rest is OK.")
                else:
                    message = ("These records got updated: "
                        + str(sucessRecords))
        return message
733007
def update(self, pci):
        """"""
        self.pduUserData = pci.pduUserData
        self.pduSource = pci.pduSource
        self.pduDestination = pci.pduDestination
653786
public static base_responses update(nitro_service client, responderpolicy resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			responderpolicy updateresources[] = new responderpolicy[resources.length];
			for (int i=0;i<resources.length;i++){
				updateresources[i] = new responderpolicy();
				updateresources[i].name = resources[i].name;
				updateresources[i].rule = resources[i].rule;
				updateresources[i].action = resources[i].action;
				updateresources[i].undefaction = resources[i].undefaction;
				updateresources[i].comment = resources[i].comment;
				updateresources[i].logaction = resources[i].logaction;
				updateresources[i].appflowaction = resources[i].appflowaction;
			}
			result = update_bulk_request(client, updateresources);
		}
		return result;
	}
826674
public static base_responses update(nitro_service client, dospolicy resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			dospolicy updateresources[] = new dospolicy[resources.length];
			for (int i=0;i<resources.length;i++){
				updateresources[i] = new dospolicy();
				updateresources[i].name = resources[i].name;
				updateresources[i].qdepth = resources[i].qdepth;
				updateresources[i].cltdetectrate = resources[i].cltdetectrate;
			}
			result = update_bulk_request(client, updateresources);
		}
		return result;
	}
1274981
def update_entitlement(owner, repo, identifier, name, token, show_tokens):
    """"""
    client = get_entitlements_api()

    data = {}
    if name is not None:
        data["name"] = name

    if token is not None:
        data["token"] = token

    with catch_raise_api_exception():
        data, _, headers = client.entitlements_partial_update_with_http_info(
            owner=owner,
            repo=repo,
            identifier=identifier,
            data=data,
            show_tokens=show_tokens,
        )

    ratelimits.maybe_rate_limit(client, headers)
    return data.to_dict()
221220
def updateSecurityPolicy(self,
                             minLength=8,
                             minUpper=None,
                             minLower=None,
                             minLetter=None,
                             minDigit=None,
                             minOther=None,
                             expirationInDays=None,
                             historySize=None):
        """"""
        params = {
            "f" : "json",
            "minLength" : minLength,
            "minUpper": minUpper,
            "minLower": minLower,
            "minLetter": minLetter,
            "minDigit": minDigit,
            "minOther": minOther,
            "expirationInDays" : expirationInDays,
            "historySize": historySize
        }
        url = "%s/securityPolicy/update" % self.root
        return self._post(url=url,
                     param_dict=params,
                     securityHandler=self._securityHandler,
                     proxy_url=self._proxy_url,
                     proxy_port=self._proxy_port)
1203467
def update(self, *args, **kwargs):
        

        dict.update(self, *args, **kwargs)
        self.__dict__.update(*args, **kwargs)
254716
public static pqpolicy get(nitro_service service, String policyname) throws Exception{
		pqpolicy obj = new pqpolicy();
		obj.set_policyname(policyname);
		pqpolicy response = (pqpolicy) obj.get_resource(service);
		return response;
	}
1215888
def update(self, **kwargs):
        """"""
        assert not self.called
        self.kw.update(kwargs)
        return self