Update the contents of this periodically sent message.

        Note the Message must have the same :attr:`~can.Message.arbitration_id`
        like the first message.
199692
def modify_data(self, message):
        
        assert message.arbitration_id == self.can_id, "You cannot modify the can identifier"
        self.message = message
        header = build_bcm_update_header(self.can_id_with_flags, self.flags)
        frame = build_can_frame(message)
        send_bcm(self.bcm_socket, header + frame)
363079
def update_from(other)
      @topic = other.topic
      @name = other.name
      @position = other.position
      @topic = other.topic
      @recipients = other.recipients
      @bitrate = other.bitrate
      @user_limit = other.user_limit
      @permission_overwrites = other.permission_overwrites
      @nsfw = other.nsfw
      @parent_id = other.parent_id
      @rate_limit_per_user = other.rate_limit_per_user
    end
899740
def update(self, entries = {}, *args, **kwargs):
        
        if isinstance(entries, dict):
            entries = self._reject_reserved_keys(entries)

        for key, value in dict(entries, *args, **kwargs).items():
            if isinstance(value, dict):
                self.__dict__[key] = AttributeDict(value)
            else:
                self.__dict__[key] = value

        self._refresh()
263385
def update_timestampable_model(sender, instance, *args, **kwargs):
    '''
    
    '''
    if not isinstance(instance, TimestampableModel):
        return
    if not instance.pk:
        instance.created_at = now()
    instance.updated_at = now()
477631
public void updateLastSeenUniqueIds(VoltMessage message)
    {
        long sequenceWithUniqueId = Long.MIN_VALUE;

        boolean commandLog = (message instanceof TransactionInfoBaseMessage &&
                (((TransactionInfoBaseMessage)message).isForReplay()));

        boolean sentinel = message instanceof MultiPartitionParticipantMessage;

        // if replay
        if (commandLog || sentinel) {
            sequenceWithUniqueId = ((TransactionInfoBaseMessage)message).getUniqueId();
            // Update last seen and last polled txnId for replicas
            m_replaySequencer.updateLastSeenUniqueId(sequenceWithUniqueId,
                    (TransactionInfoBaseMessage) message);
            m_replaySequencer.updateLastPolledUniqueId(sequenceWithUniqueId,
                    (TransactionInfoBaseMessage) message);
        }
    }
207644
def update_contact(self, um_from_user, um_to_user, message):
        
        contact, created = self.get_or_create(um_from_user,
                                              um_to_user,
                                              message)

        # If the contact already existed, update the message
        if not created:
            contact.latest_message = message
            contact.save()
        return contact
464081
def update(self, resource, rid, updates):
        
        if resource[-1] != '/':
            resource += '/'
        resource += str(rid)
        return self.put(resource, data=updates)
794100
private void updateMessage(byte messageSystemId) throws IOException
    {
        switch (messageSystemId)
        {
            case NetworkMessageSystemId.CONNECTING:
                updateConnecting();
                break;
            case NetworkMessageSystemId.CONNECTED:
                updateConnected();
                break;
            case NetworkMessageSystemId.PING:
                ping = (int) pingTimer.elapsed();
                break;
            case NetworkMessageSystemId.KICKED:
                kick();
                break;
            case NetworkMessageSystemId.OTHER_CLIENT_CONNECTED:
                updateOtherClientConnected();
                break;
            case NetworkMessageSystemId.OTHER_CLIENT_DISCONNECTED:
                updateOtherClientDisconnected();
                break;
            case NetworkMessageSystemId.OTHER_CLIENT_RENAMED:
                updateOtherClientRenamed();
                break;
            case NetworkMessageSystemId.USER_MESSAGE:
                updateUserMessage();
                break;
            default:
                break;
        }
    }
859508
def update(self, display_name=None, display_description=None):
        
        return self.manager.update(self, display_name=display_name,
                display_description=display_description)
365364
def update(self, update_finished_cb):
        """"""
        if not self._update_finished_cb:
            self._update_finished_cb = update_finished_cb
            self.anchor_data = []
            self.nr_of_anchors = 0
            self.valid = False
            logger.debug('Updating content of memory {}'.format(self.id))

            # Start reading the header
            self.mem_handler.read(self, LocoMemory.MEM_LOCO_INFO,
                                  LocoMemory.MEM_LOCO_INFO_LEN)
1019667
def update(message)
      case message.fetch(:type){""}
      when "error"
        logger.error message
      else
        logger.info message
      end
      exchange_out.publish(message.to_json)
    end
603522
def _update_text_record(self, witness, text_id):
        
        checksum = witness.get_checksum()
        token_count = len(witness.get_tokens())
        with self._conn:
            self._conn.execute(constants.UPDATE_TEXT_SQL,
                               [checksum, token_count, text_id])
1094961
def __update_interval(self):
        
        self.update()
        self.after_id = self.text.after(250, self.__update_interval)
1078779
def updateNewsBulletin(self, msgId, msgType, newsMessage, originExch):
        """"""
        return _swigibpy.EWrapper_updateNewsBulletin(self, msgId, msgType, newsMessage, originExch)
157130
public void update(final int numSent) {

		// Reset the last HTTP error

		lastHttpError = 0;

		// adjust the schedule delay based on the number of messages sent in the last iteration

		if (100 <= numSent) {

			// messages are coming in quickly so decrease our delay
			// minimum delay is 1 second

			scheduleDelay = Math.max(Math.round(scheduleDelay / 2.0), ONE_SECOND);

		} else if (numSent < 10) {

			// messages are coming in rather slowly so increase our delay
			// maximum delay is 5 seconds

			scheduleDelay = Math.min(Math.round(1.25 * scheduleDelay), FIVE_SECONDS);

		}
	}
60636
def __update_existing(self, msg, req):
        """"""
        req._messages.append(msg)

        payload = msg[M_PAYLOAD]
        if msg[M_TYPE] in _RSP_TYPE_CREATION:
            if payload[P_RESOURCE] == R_SUB:
                # Add callback for feeddata
                with self.__pending_subs:
                    if msg[M_CLIENTREF] in self.__pending_subs:
                        callback = self.__pending_subs.pop(msg[M_CLIENTREF])
                        if payload[P_POINT_TYPE] == R_FEED:
                            self.__callbacks[_CB_FEED][payload[P_POINT_ID]] = callback
                        else:
                            logger.warning('Subscription intended to feed is actually control: %s', payload[P_POINT_ID])

            elif payload[P_RESOURCE] == R_CONTROL:
                with self.__pending_controls:
                    if msg[M_CLIENTREF] in self.__pending_controls:
                        # callbacks by thing
                        entity_point_callbacks = self.__callbacks[_CB_CONTROL].setdefault(payload[P_ENTITY_LID], {})
                        # callback by thing and point
                        entity_point_callbacks[payload[P_LID]] = self.__pending_controls.pop(msg[M_CLIENTREF])

        elif msg[M_TYPE] == E_RECENTDATA:
            samples = []
            for sample in payload[P_SAMPLES]:
                data, mime, time = self.__decode_data_time(sample)
                samples.append({'data': data, 'mime': mime, 'time': time})
            self.__fire_callback(_CB_RECENT_DATA, {'c': msg[M_CLIENTREF],
                                                   'samples': samples})
1156076
def update_recurring_item(self, recurring_item_id, recurring_item_dict):
        
        return self._create_put_request(
            resource=RECURRING_ITEMS,
            billomat_id=recurring_item_id,
            send_data=recurring_item_dict
        )