Update the list of event with the latest ones
482164
def updateEvent(self, event=None, home=None):
        
        if not home: home=self.default_home
        if not event:
            #If not event is provided we need to retrieve the oldest of the last event seen by each camera
            listEvent = dict()
            for cam_id in self.lastEvent:
                listEvent[self.lastEvent[cam_id]['time']] = self.lastEvent[cam_id]
            event = listEvent[sorted(listEvent)[0]]

        home_data = self.homeByName(home)
        postParams = {
            "access_token" : self.getAuthToken,
            "home_id" : home_data['id'],
            "event_id" : event['id']
        }
        resp = postRequest(_GETEVENTSUNTIL_REQ, postParams)
        eventList = resp['body']['events_list']
        for e in eventList:
            self.events[ e['camera_id'] ][ e['time'] ] = e
        for camera in self.events:
            self.lastEvent[camera]=self.events[camera][sorted(self.events[camera])[-1]]
402218
function updateSimple(newList, oldList, rawNewValue ){

    var nlen = newList.length;
    var olen = oldList.length;
    var mlen = Math.min(nlen, olen);

    updateRange(0, mlen, newList, rawNewValue)
    if(nlen < olen){ //need add
      removeRange(nlen, olen-nlen, children);
    }else if(nlen > olen){
      addRange(olen, nlen, newList, rawNewValue);
    }
  }
923619
def updateObj(self, event):
        """"""

        name = self.objList.get("active")
        self.SearchVar.set(name)
        self.object_info.set(str(self.kbos.get(name, '')))
        return
1018859
def normalize_events_list(old_list):
    """"""
    new_list = []
    for _event in old_list:
        new_event = dict(_event)
        if new_event.get('args'):
            new_event['args'] = dict(new_event['args'])
            encode_byte_values(new_event['args'])
        # remove the queue identifier
        if new_event.get('queue_identifier'):
            del new_event['queue_identifier']
        # the events contain HexBytes values, convert those to strings
        hexbytes_to_str(new_event)
        # Some of the raiden events contain accounts and as such need to
        # be exported in hex to the outside world
        name = new_event['event']
        if name == 'EventPaymentReceivedSuccess':
            new_event['initiator'] = to_checksum_address(new_event['initiator'])
        if name in ('EventPaymentSentSuccess', 'EventPaymentSentFailed'):
            new_event['target'] = to_checksum_address(new_event['target'])
        encode_byte_values(new_event)
        # encode unserializable objects
        encode_object_to_str(new_event)
        new_list.append(new_event)
    return new_list
548145
def each_new_event
      new_events = []
      stack.events.each do |event|
        break if event.id == @last_processed_event_id
        new_events.unshift(event)
      end
      new_events.each do |event|
        yield event
        @last_processed_event_id = event.id
      end
    rescue Aws::CloudFormation::Errors::ValidationError => _e
    end
508622
def update_event_types(self):
        """"""
        self.idx_evt_type.clear()
        self.idx_evt_type.setSelectionMode(QAbstractItemView.ExtendedSelection)
        event_types = sorted(self.parent.notes.annot.event_types,
                             key=str.lower)

        for ty in event_types:
            item = QListWidgetItem(ty)
            self.idx_evt_type.addItem(item)
1267919
def get_events(self):
        '''
        
        '''
        ret = []
        while True:
            event = self.event.get_event(wait=1, full=True)
            if event is None:
                return ret
            ret.append(event)
992906
def _update_activities(self):
        """"""
        self._activities = self._activities_request()
        _LOGGER.debug("Device Activities Response: %s", self._activities)

        if not self._activities:
            self._activities = []
        elif not isinstance(self._activities, (list, tuple)):
            self._activities = [self._activities]

        self._update_events()
1113121
def update(self):
        """"""
        self.filename = self.parent.notes.annot.xml_file
        
        self.event_types = self.parent.notes.annot.event_types
        self.idx_evt_type.clear()
        for ev in self.event_types:
            self.idx_evt_type.addItem(ev)
919974
def update(self, title, unsubscribe_page, confirmed_opt_in,
               confirmation_success_page, unsubscribe_setting="AllClientLists",
               add_unsubscribes_to_supp_list=False, scrub_active_with_supp_list=False):
        """"""
        body = {
            "Title": title,
            "UnsubscribePage": unsubscribe_page,
            "ConfirmedOptIn": confirmed_opt_in,
            "ConfirmationSuccessPage": confirmation_success_page,
            "UnsubscribeSetting": unsubscribe_setting,
            "AddUnsubscribesToSuppList": add_unsubscribes_to_supp_list,
            "ScrubActiveWithSuppList": scrub_active_with_supp_list}
        response = self._put("/lists/%s.json" % self.list_id, json.dumps(body))
357572
def OrEvent(*events):
    '''
    
    '''
    or_event = threading.Event()

    def changed():
        '''
        Set ``or_event`` if any of the specified events have been set.
        '''
        bools = [event_i.is_set() for event_i in events]
        if any(bools):
            or_event.set()
        else:
            or_event.clear()
    for event_i in events:
        # Override ``set`` and ``clear`` methods on event to update state of
        # `or_event` after performing default behaviour.
        orify(event_i, changed)

    # Set initial state of `or_event`.
    changed()
    return or_event
727396
function() {
      var updateEvents = this.__parseUpdateEvents();
      _.each(updateEvents, function(parsedUpdateEvent) {
        this.stopListening(parsedUpdateEvent.idContainer, parsedUpdateEvent.eventName, this.retrieve);
      }, this);
    }
637616
function() {
      _.each(this.__currentUpdateEvents, function(eventConfig) {
        this.stopListening(eventConfig.model, eventConfig.eventName);
      }, this);
      this.__currentUpdateEvents = [];
    }
329325
function() {
		
		var self = this;
		var viewList = this.list();
		
		$.each(viewList, function(i, view) {
			
			self.cmp().trigger("view.update");
			
		});
		
		return this;
	}
694666
private void updateValue() {
        if (table != null) {
            int oldCount = this.count;
            this.count = table.getSelectedRowCount();
            maybeNotifyListeners(oldCount, count);
        }
    }
1333652
def _update_fs_list(self):
        """"""
        from json import dumps

        full_list = [ e[1] for e in self._list_fs(full=True) ]

        remote = self._fs_remote(self.url)

        remote.setcontents(os.path.join('_meta', 'list.json'), dumps(full_list, indent = 4))
1294654
def refresh_listing():
    """"""
    for program in get_programs():
        if re.match(r'^[a-zA-Z_][a-zA-Z_0-9]*$', program) is not None:
            globals()[program] = partial(_run_program, program)

    globals()["_"] = _underscore_run_program