Method to update vip's

        :param vips: List containing vip's desired to updated
        :return: None
346062
def update(self, vips):
        

        data = {'vips': vips}
        vips_ids = [str(vip.get('id')) for vip in vips]

        return super(ApiVipRequest, self).put('api/v3/vip-request/%s/' %
                                              ';'.join(vips_ids), data)
576636
def update_settings(self, index, newvalues):
        
        path = make_path(index, "_settings")
        return self.conn._send_request('PUT', path, newvalues)
17035
def update_wrapper(wrapper,
                   wrapped,
                   assigned = functools.WRAPPER_ASSIGNMENTS,
                   updated = functools.WRAPPER_UPDATES):
    
    # workaround for http://bugs.python.org/issue3445
    assigned = tuple(attr for attr in assigned if hasattr(wrapped, attr))
    wrapper = functools.update_wrapper(wrapper, wrapped, assigned, updated)
    # workaround for https://bugs.python.org/issue17482
    wrapper.__wrapped__ = wrapped
    return wrapper
944305
def update(self, dictionary=None, **kwargs):
        
        if not dictionary == None: kwargs.update(dictionary)
        for k in list(kwargs.keys()): self[k] = kwargs[k]
1079642
def _UpdateUsers(self, update_users):
    
    for user, ssh_keys in update_users.items():
      if not user or user in self.invalid_users:
        continue
      configured_keys = self.user_ssh_keys.get(user, [])
      if set(ssh_keys) != set(configured_keys):
        if not self.utils.UpdateUser(user, ssh_keys):
          self.invalid_users.add(user)
        else:
          self.user_ssh_keys[user] = ssh_keys[:]
103184
def update(self, cid, session, name=None, pict_url=None, sort_order=None):
        ''''''
        request = TOPRequest('taobao.sellercats.list.update')
        request['cid'] = cid
        if name!=None: request['name'] = name
        if pict_url!=None: request['pict_url'] = pict_url
        if sort_order!=None: request['sort_order'] = sort_order
        self.create(self.execute(request, session)['seller_cat'])
        return self
751847
def update(self, environments):
        

        data = {'environments_vip': environments}
        environments_ids = [str(env.get('id')) for env in environments]

        uri = 'api/v3/environment-vip/%s/' % ';'.join(environments_ids)
        return super(ApiEnvironmentVip, self).put(uri, data)
812675
def _update(self, datapoints):
        
        if len(datapoints) == 1:
            timestamp, value = datapoints[0]
            whisper.update(self.path, value, timestamp)
        else:
            whisper.update_many(self.path, datapoints)
1098177
def updateParamsets(self):
        
        try:
            for ps in self._PARAMSETS:
                self.updateParamset(ps)
            return True
        except Exception as err:
            LOG.error("HMGeneric.updateParamsets: Exception: " + str(err))
            return False
26603
def update(collection_name, upsert, multi,
           spec, doc, safe, last_error_args, check_keys, opts):
    
    options = 0
    if upsert:
        options += 1
    if multi:
        options += 2

    data = _ZERO_32
    data += bson._make_c_string(collection_name)
    data += struct.pack("<i", options)
    data += bson.BSON.encode(spec, False, opts)
    encoded = bson.BSON.encode(doc, check_keys, opts)
    data += encoded
    if safe:
        (_, update_message) = __pack_message(2001, data)
        (request_id, error_message, _) = __last_error(collection_name,
                                                      last_error_args)
        return (request_id, update_message + error_message, len(encoded))
    else:
        (request_id, update_message) = __pack_message(2001, data)
        return (request_id, update_message, len(encoded))
514852
def update(self):
        
        con = self.subpars.pars.control
        self(con.eqi1*con.tind)
1348948
def pipupdate():
    

    packages = [d for d in pkg_resources.working_set]
    subprocess.call('pip install --upgrade ' + ' '.join(packages))
334904
def update(self, sha, force=False):
        
        data = {'sha': sha, 'force': force}
        json = self._json(self._patch(self._api, data=dumps(data)), 200)
        if json:
            self._update_(json)
            return True
        return False
361771
def update(cls, spec, updates, upsert=False):
        '''
        
        '''
        if 'key' in spec:
            previous = cls.get(spec['key'])
        else:
            previous = None
        if previous:
            # Update existing data.
            current = cls(**previous.__dict__)
        elif upsert:
            # Create new data.
            current = cls(**spec)
        else:
            current = None
        # XXX Should there be any error thrown if this is a noop?
        if current:
            current.__dict__.update(updates)
            current.save()
        return current
499798
def update_intervals(self, back=None):
        '''
        
        '''
        back = self.backends(back)
        ret = {}
        for fsb in back:
            fstr = '{0}.update_intervals'.format(fsb)
            if fstr in self.servers:
                ret[fsb] = self.servers[fstr]()
        return ret
543300
def upgrade_plan(self, subid, vpsplanid, params=None):
        ''' 
        '''
        params = update_params(params, {
            'SUBID': subid,
            'VPSPLANID': vpsplanid
        })
        return self.request('/v1/server/upgrade_plan', params, 'POST')
916858
def update(self, **kwargs):
        
        for k in self.prior_params:
            try:
                self.params[k] = kwargs[self.alias[k]]
            except(KeyError):
                pass