Store the given key:value pair for the item associated with handle.

        :param handle: handle for accessing an item before the dataset is
                       frozen
        :param key: metadata key
        :param value: metadata value
435617
def add_item_metadata(self, handle, key, value):
        
        _mkdir_if_missing(self._metadata_fragments_abspath)

        prefix = self._handle_to_fragment_absprefixpath(handle)
        fpath = prefix + '.{}.json'.format(key)

        _put_obj(fpath, value)
566950
def put(self, key, value, overwrite=True):
        
        self._get_table()
        s = self.to_string(value)
        log.debug("Storing in key '%s' the object: '%s'" % (key, s))
        self.table.put_item(
            data={
                'key': key,
                'value': s,
            },
            overwrite=overwrite
        )
466538
function DictionaryItem(key, value) {
    this.key = ko.observable(key);
	this.options = [];
    if(value instanceof Array){
		this.options = value;
		value = value[0];
    }
    this.value = (typeof(value)==='function')? value : ko.observable(value);
}
247465
def add(self, key: str, value: str):
        
        if key in self:
            # Use super to get mutable set
            super().__getitem__(key).add(value)
        else:
            self[key] = {value}
818570
def set(self, key, value):
        
        self._check_limit()
        _expire = time.time() + self._timeout if self._timeout else None
        self._store[key] = (value, _expire)
330114
def _store_variable(self, j, key, m, value):
        
        if hasattr(value, 'copy'):
            v = value.copy()
        else:
            v = value

        self.history[j][key][m].append(v)
713734
def saveDataSet( settings, key, dataSet ):
    
    for datakey, value in dataSet.items():
        datatype  = type(value).__name__
        
        if ( datatype in _dataValueTypes ):
            datavalue = _dataValueTypes[datatype][0](value)
        else:
            datavalue = value
        
        settings.setValue('%s/%s/type' % (key, datakey), wrapVariant(datatype))
        settings.setValue('%s/%s/value' % (key, datakey), wrapVariant(datavalue))
1314634
def set(self, key, value):
        
        db = self.open()
        try:
            db[key] = value
        finally:
            db.close()
138160
def put(self, key, value):
    ''''''
    for store in self._stores:
      store.put(key, value)
674308
def set(self, key, value):
        
        return self.__setitem__(key, value, force=True)
407704
def set(self, key, value):
        
        value_encoded = encode(value, self.get_change_trigger(key))

        if key in self.data and self.data[key] == value_encoded:
            return self

        self.data[key] = value_encoded
        return self.trigger_changed(key)
204352
def set_metadata(self, key, metadata):
        
        with self._lock:
            self._metadata[key] = metadata
156246
def set(self, key, data):
        '''
        
        '''
        if isinstance(data, dict):
            self._volatile_data[key] = {k: v for (k, v) in data.items()}
        else:
            self._volatile_data[key] = data
733163
def extern_store_dict(self, context_handle, vals_ptr, vals_len):
    
    c = self._ffi.from_handle(context_handle)
    tup = tuple(c.from_value(val[0]) for val in self._ffi.unpack(vals_ptr, vals_len))
    d = dict()
    for i in range(0, len(tup), 2):
      d[tup[i]] = tup[i + 1]
    return c.to_value(d)
904043
def set_metadata(self, key: str, value: str):
        
        if not isinstance(key, str) or not isinstance(value, str):
            raise TypeError("'key' and 'value' of metadata MUST be strings")
        self.metadata[key] = value
1187595
def use(self, key, value):
        
        old_value = self[key]
        try:
            self[key] = value
            yield self
        finally:
            self[key] = old_value
821025
def put(self, key, value):
    '''
    '''
    self.cache_datastore.put(key, value)
    self.child_datastore.put(key, value)