Go through the whole key jar, key bundle by key bundle and update them one
    by one.

    :param keyjar: The key jar to update
176293
def update_keyjar(keyjar):
    
    for iss, kbl in keyjar.items():
        for kb in kbl:
            kb.update()
106932
public void update( Key job_key ) { 
    Log.debug(Log.Tag.Sys.LOCKS,"update write-locked "+_key+" by job "+job_key);
    new Update(job_key).invoke(_key); 
  }
647914
def update(self, **kwargs):
        
        self.configure(**kwargs)
        self.get_all_requirements()
        self.apply_updates(
            initial=kwargs.get("initial", False),
            scheduled=kwargs.get("scheduled", False)
        )

        return self.req_bundle
756425
def update(key, ctx)
      resp = _request_endpoint(ctx)
      if resp && resp.endpoints
        resp.endpoints.each { |e| self[key] = e }
      end
    end
914371
private void addKeyListenerImpl(KeyListener listener) {
		if (keyListeners.contains(listener)) {
			return;
		}
		keyListeners.add(listener);
		allListeners.add(listener);
	}
730341
def update(access_key, resource_policy, is_admin, is_active,  rate_limit):
    '''
    
    '''
    with Session() as session:
        try:
            data = session.KeyPair.update(
                access_key,
                is_active=is_active,
                is_admin=is_admin,
                resource_policy=resource_policy,
                rate_limit=rate_limit)
        except Exception as e:
            print_error(e)
            sys.exit(1)
        if not data['ok']:
            print_fail('KeyPair creation has failed: {0}'.format(data['msg']))
            sys.exit(1)
        print('Key pair is updated: ' + access_key + '.')
1371509
def keyring_edit(**kwargs):
    
    ctx = Context(**kwargs)
    ctx.timeout = None
    ctx.execute_action('keyring:edit', **{
        'storage': ctx.repo.create_secure_service('storage'),
    })
686657
async def update(self):
    '''
    
    '''
    keys = self.extras.keys()
    self.extras = {}
    for key in keys:
      try:
        func = getattr(self, key, None)
        if callable(func):
          func()
      except:
        pass
1303442
def _update(self, data: TransDict, *args, **kwargs):
        

        for l in self.listeners:
            l(data, *args, **kwargs)
208617
def update(self, *others):
        """"""
        self.db.sunionstore(self.key, [self.key] + [o.key for o in others])
641642
def do_gui_update(self):
        
        with self.update_lock:
            changed_widget_dict = {}
            self.root.repr(changed_widget_dict)
            for widget in changed_widget_dict.keys():
                html = changed_widget_dict[widget]
                __id = str(widget.identifier)
                self._send_spontaneous_websocket_message(_MSG_UPDATE + __id + ',' + to_websocket(html))
        self._need_update_flag = False
1006207
def add_bundled_jars():
    
    # determine lib directory with jars
    rootdir = os.path.split(os.path.dirname(__file__))[0]
    libdir = rootdir + os.sep + "lib"

    # add jars from lib directory
    for l in glob.glob(libdir + os.sep + "*.jar"):
        if l.lower().find("-src.") == -1:
            javabridge.JARS.append(str(l))
814339
def update(self, **kwargs):
        
        for kw in kwargs:
            setattr(self, kw, kwargs[kw])
129059
def update_from_dict(self, keywords):
        
        for key, value in list(keywords.items()):
            setattr(self, key, value)
1134094
def update(cls, **kwargs):
        '''
        
        '''
        q = cls._get_instance(**{'id': kwargs['id']})
        if q:
            for k, v in kwargs.items():
                setattr(q, k, v)
            _action_and_commit(q, session.add)
        else:
            cls.get_or_create(**kwargs)
1248930
def update(self, title, key):
        
        json = None
        if title and key:
            data = {'title': title, 'key': key}
            json = self._json(self._patch(self._api, data=dumps(data)), 200)
        if json:
            self._update_(json)
            return True
        return False
812228
def update(self, key=values.unset, value=values.unset):
        
        data = values.of({'Key': key, 'Value': value, })

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

        return VariableInstance(
            self._version,
            payload,
            service_sid=self._solution['service_sid'],
            environment_sid=self._solution['environment_sid'],
            sid=self._solution['sid'],
        )