Update a status name

        :type id_number: int
        :param id_number: status ID number

        :type new_value: str
        :param new_value: The new status name

        :rtype: dict
        :return: an empty dictionary
494132
def update_status(self, id_number, new_value):
        
        data = {
            'id': id_number,
            'new_value': new_value
        }

        return self.post('updateStatus', data)
545728
def id(self, id):
        
        if id is None:
            raise ValueError("Invalid value for `id`, must not be `None`")
        if id is not None and len(id) > 250:
            raise ValueError("Invalid value for `id`, length must be less than or equal to `250`")
        if id is not None and len(id) < 1:
            raise ValueError("Invalid value for `id`, length must be greater than or equal to `1`")

        self._id = id
701308
def check_number_status(self, number_id):
        
        number_status = self.wapi_functions.checkNumberStatus(number_id)
        return NumberStatus(number_status, self)
605727
def set_status(self, new_status):
        '''
        
        '''
        if new_status not in Report.allowed_statuses:
            raise Exception('status must be one of: %s' % (', '.join(Report.allowed_statuses)))
        self._data_fields['status'] = new_status.lower()
1099979
def usable_id(cls, id):
        
        hcs = cls.from_fqdn(id)
        if hcs:
            return [hc_['id'] for hc_ in hcs]

        try:
            return int(id)
        except (TypeError, ValueError):
            pass
605961
def _update_dict(self, newdict):
        
        if self.bugzilla:
            self.bugzilla.post_translation({}, newdict)

            # pylint: disable=protected-access
            aliases = self.bugzilla._get_bug_aliases()
            # pylint: enable=protected-access

            for newname, oldname in aliases:
                if oldname not in newdict:
                    continue

                if newname not in newdict:
                    newdict[newname] = newdict[oldname]
                elif newdict[newname] != newdict[oldname]:
                    log.debug("Update dict contained differing alias values "
                              "d[%s]=%s and d[%s]=%s , dropping the value "
                              "d[%s]", newname, newdict[newname], oldname,
                            newdict[oldname], oldname)
                del(newdict[oldname])

        for key in newdict.keys():
            if key not in self._bug_fields:
                self._bug_fields.append(key)
        self.__dict__.update(newdict)

        if 'id' not in self.__dict__ and 'bug_id' not in self.__dict__:
            raise TypeError("Bug object needs a bug_id")
193752
def id_generator(start=0):
    
    count = start
    while True:
        send_value = (yield count)
        if not send_value is None:
            if send_value < count:
                raise ValueError('Values from ID generator must increase '
                                 'monotonically (current value: %d; value '
                                 'sent to generator: %d).'
                                 % (count, send_value))
            count = send_value
        else:
            count += 1
228552
def scheduled_status_update(self, id, scheduled_at):
        
        scheduled_at = self.__consistent_isoformat_utc(scheduled_at)
        id = self.__unpack_id(id)
        params = self.__generate_params(locals(), ['id'])
        url = '/api/v1/scheduled_statuses/{0}'.format(str(id))
        return self.__api_request('PUT', url, params)
488085
def update(self, entry_id, new_label):
        
        self.data[entry_id] = (self.data[entry_id][0], new_label)
        self.modified = True
        for callback in self._update_callback:
            callback(entry_id, new_label)
1309786
def change_interface_id(self, interface_id):
        
        _, second = self.nicid.split('.')
        self.update(nicid='{}.{}'.format(str(interface_id), second))
860217
def id(self, id):
        

        if id is None:
            raise ValueError("Invalid value for `id`, must not be `None`")
        if len(id) > 255:
            raise ValueError("Invalid value for `id`, length must be less than `255`")

        self._id = id
569394
def update(self, identifier, new_instance):
        
        old_instance = self.retrieve(identifier)
        old_encrypted_identifier = old_instance.encrypted_identifier

        if (
            new_instance.encryption_context_key and
            old_instance.encryption_context_key != new_instance.encryption_context_key
        ):
            raise ValueError("Cannot change encryption context key")

        # If updating a non encrypted field - skip
        if new_instance.plaintext is None and new_instance.encrypted_relationship is None:
            result = super().update(identifier, new_instance)
            self.expunge(result)
            return result

        # Verify that the new instance is encrypted if it should be
        # If it's not - encrypt it with the old key
        # If it is - save the expected new plaintext
        if new_instance.plaintext is not None:
            expected_new_plaintext = new_instance.plaintext
            new_instance = self.reencrypt_instance(new_instance, old_instance.encryption_context_key)
        else:
            decrypt, expected_new_plaintext = decrypt_instance(new_instance)

        result = super().update(identifier, new_instance)

        # Delete the old encrypted value (instead of using sqlalchemy cascade)
        if old_encrypted_identifier != new_instance.encrypted_identifier:
            self.encrypted_store.delete(old_encrypted_identifier)

        # Update the return result, super().update() won't do it.
        self.expunge(result)
        result.plaintext = expected_new_plaintext
        return result
917517
public void updateRepeatNumber(int newNum, int path_id, String client_uuid) throws Exception {
        updateRequestResponseTables("repeat_number", newNum, getProfileIdFromPathID(path_id), client_uuid, path_id);
    }
635412
def update(self, id, **dict):
        ''''''
        if not self._item_path:
            raise AttributeError('update is not available for %s' % self._item_name)
        target = (self._update_path or self._item_path) % id
        payload = json.dumps({self._item_type:dict})
        self._redmine.put(target, payload)
        return None
1072904
def set_status(self, new_status, notes=None):
        ''''''
        self.status_id = new_status
        try:
            self.status['id'] = self.status_id
            # We don't have the id to name mapping, so blank the name
            self.status['name'] = None
        except:
            pass
        self.save(notes)
143112
def _update_id_list(self):
        """"""
        self.id_list = [id(self.editor.tabs.widget(_i))
                        for _i in range(self.editor.tabs.count())]
1072240
def update_id(self, sequence_id=None):
        """"""
        from ..identity import GeneralNumber1

        if sequence_id:
            self.sequence_id = sequence_id

        self.vid = str(GeneralNumber1('T', self.d_vid, self.sequence_id))