Updates an existing key.
433860
def update(self, key, value=None, dir=False, ttl=None, refresh=False,
               prev_value=None, prev_index=None, timeout=None):
        """"""
        return self.adapter.set(key, value, dir=dir, ttl=ttl, refresh=refresh,
                                prev_value=prev_value, prev_index=prev_index,
                                prev_exist=True, timeout=timeout)
253198
def update(self, key, value):
        
        if not is_string(key):
            raise Exception("Key must be string")

        # if len(key) > 32:
        #     raise Exception("Max key length is 32")

        if not is_string(value):
            raise Exception("Value must be string")

        # if value == '':
        #     return self.delete(key)
        self.root_node = self._update_and_delete_storage(
            self.root_node,
            bin_to_nibbles(to_string(key)),
            to_string(value))
        self._update_root_hash()
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); 
  }
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'],
        )
903750
def update(self, *args, **kwargs):
        """"""
        self._call_helper("Updating", self.real.update, *args, **kwargs)
845185
def update(self, mapping):
        """"""
        return self.api.mset(dict((key, self.prepare_value(value))
                                for key, value in mapping.items()))
1151221
def update(key, value):
    '''
    
    '''
    store = load()
    store[key] = value
    dump(store)
    return True
948971
def upsert(self, events):
        """"""
        existing = self.get_existing_keys(events)
        inserts = [e for e in events if not e[self.key] in existing]
        updates = [e for e in events if e[self.key] in existing]
        self.insert(inserts)
        self.update(updates)
794874
def rename_key(d: Dict[str, Any], old: str, new: str) -> None:
    
    d[new] = d.pop(old)
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
689052
def rename(self, old_name, new_name):
        """"""
        try:
            self.api.rename(mkey(old_name), mkey(new_name))
        except ResponseError, exc:
            if "no such key" in exc.args:
                raise KeyError(old_name)
            raise
260487
def update_credentials(self, key, secret):
        '''  '''
        self.access_key = key
        self.secret_key = secret
408905
public void updateMethodKey() {
        Arrays.stream(ParamType.values()).forEach(paramType -> this.syncMethodKey(paramType));

        this.validationDataRepository.flush();
        this.validationStore.refresh();
        log.info("[METHOD_KEY_SYNC] Complete");
    }
567800
def update(self, dictionary):
        """"""
        allowed_attrs = list(self.__attributes__.keys())
        allowed_attrs += [a.alias for a in self.__attributes__.values()]
        for k in dictionary:
            # We only update existing attributes
            if k in allowed_attrs:
                setattr(self, k, dictionary[k])
        return self
1262492
function rename(key, newkey, req) {
  var val = this.getKey(key);
  this.delKey(key);
  this.setKey(newkey, val);
  return OK;
}
82882
def increment_key(key):
    
    pipe = REDIS_SERVER.pipeline()
    pipe.incr(key, 1)
    if config.COOLOFF_TIME:
        pipe.expire(key, config.COOLOFF_TIME)
    new_value = pipe.execute()[0]
    return new_value
1264551
def update(self, *args, **kwargs):
        
        if args:
            self.database.hmset(self.key, *args)
        else:
            self.database.hmset(self.key, kwargs)