Set key to a copy of items
186016
def set(self, key, items):
        """"""
        if not isinstance(items, list):
            raise ValueError("items must be a list")
        with self._lock:
            self._dict[key] = items.copy()
490045
def handle_set_key(self):
        """"""
        track_id = self.reader.int()
        row = self.reader.int()
        value = self.reader.float()
        kind = self.reader.byte()
        logger.info(" -> track=%s, row=%s, value=%s, type=%s", track_id, row, value, kind)

        # Add or update track value
        track = self.tracks.get_by_id(track_id)
        track.add_or_update(row, value, kind)
6078
def pop_to(source, dest, key, name=None):
    
    value = source.pop(key, None)
    if value is not None:
        safe_setitem(dest, key, value, name=name)
    return value
1050368
def set_key(dotenv_path, key_to_set, value_to_set, quote_mode="always"):
    
    value_to_set = value_to_set.strip("'").strip('"')
    if not os.path.exists(dotenv_path):
        warnings.warn("can't write to %s - it doesn't exist." % dotenv_path)
        return None, key_to_set, value_to_set

    if " " in value_to_set:
        quote_mode = "always"

    line_template = '{}="{}"\n' if quote_mode == "always" else '{}={}\n'
    line_out = line_template.format(key_to_set, value_to_set)

    with rewrite(dotenv_path) as (source, dest):
        replaced = False
        for mapping in parse_stream(source):
            if mapping.key == key_to_set:
                dest.write(line_out)
                replaced = True
            else:
                dest.write(mapping.original)
        if not replaced:
            dest.write(line_out)

    return True, key_to_set, value_to_set
651153
def convert_items(self, items):
        """"""
        return ((key, self.convert(value, self)) for key, value in items)
544845
def set(self, key, value, glob=False):
        """"""
        ns = self.namespace(key, glob)
        self.keyring.set_password(ns, key, value)
1252986
def _direct_set(self, key, value):
        '''
            

        '''
        dict.__setitem__(self, key, value)
        return value
247358
def set(self, key, value):
        """"""
        value = pickle.dumps(value, protocol=constants.PICKLE_PROTOCOL)
        redis_conn.set(key, 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
        )
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
1098918
private void copyKeys(int upToKeyPosition)
    {
        if (copyFromKeyPosition >= upToKeyPosition)
            return;

        int len = upToKeyPosition - copyFromKeyPosition;
        assert len <= FAN_FACTOR : upToKeyPosition + "," + copyFromKeyPosition;

        ensureRoom(buildKeyPosition + len);
        if (len > 0)
        {
            System.arraycopy(copyFrom, copyFromKeyPosition, buildKeys, buildKeyPosition, len);
            copyFromKeyPosition = upToKeyPosition;
            buildKeyPosition += len;
        }
    }
1095931
def set(self, key, value):
        """"""
        self.store[key]=value
        return self.store
1217271
function copy(from, to) {
      var name;
      for (name in from) {
        if (from.hasOwnProperty(name)) {
          to[name] = from[name];
        }
      }
    }
906408
def copy(self):
        """"""
        return self.__class__(self._key, self._load, self._iteritems())
1317299
protected void copyIfSet(Properties target, String key) {
		String value = this.properties.get(key);
		if (StringUtils.hasText(value)) {
			target.put(key, value);
		}
	}
186458
def _setitem_with_key_seq(self, key_seq, value):
        
        table = self
        key_so_far = tuple()
        for key in key_seq[:-1]:
            key_so_far += (key,)
            self._make_sure_table_exists(key_so_far)
            table = table[key]
        table[key_seq[-1]] = value
82666
def setitem_without_overwrite(d, key, value):
    
    if key in d:
        raise OverwriteError(key, value, d[key])
    else:
        dict.__setitem__(d, key, value)