Remove a given block from wantlist.

        Parameters
        ----------
        key : str
            Key to remove from wantlist.
968840
def bitswap_unwant(self, key, **kwargs):
        
        args = (key,)
        return self._client.request('/bitswap/unwant', args, **kwargs)
717459
public Object remove(Object key)
    {
        Object underlying = this.underlyingObjectGetter.getUnderlyingObject(key);
        return removeUsingUnderlying(underlying);
    }
1001484
def remove_column(self, key):
        
        if isinstance(key, int):
            index = key
            key = self.row_columns[key]
        else:
            index = self._column_index[key]
        for row in self.table:
            row.pop(index)
        self.row_columns = self.row_columns[:index] + self.row_columns[
                                                      index + 1:]
        self.pop_column(key)
1158374
def remove_all_for(self, key):
        
        if not isinstance(key, _string_type):
            raise TypeError("Key need to be a string.")

        for idx in _range(self.__kcount[key]):
            super(VDFDict, self).__delitem__((idx, key))

        self.__omap = list(filter(lambda x: x[1] != key, self.__omap))

        del self.__kcount[key]
944455
def delete_row(self, key, value):
        
        self.rows = filter(lambda x: x.get(key) != value, self.rows)
162505
def pop(self, key):
        """"""
        arr = dict.pop(self, key).copy()
        self.remover(key)
        return arr
1359465
public Object remove (int key)
    {
        int size = _keys.length, start = key % size;
        for (int ii = 0; ii < size; ii++) {
            int idx = (ii + start) % size;
            if (_keys[idx] == key) {
                Object value = _values[idx];
                _keys[idx] = -1;
                _values[idx] = null;
                return value;
            }
        }
        return null;
    }
1025509
def forget(self, key):
        
        return bool(self._redis.delete(self._prefix + key))
1235751
InventoryEntry remove(String key) {
		InventoryEntry ret = configs.remove(key);
		if (ret!=null) {
			ret.getPath().delete();
		}
		return ret;
	}
1163168
def delete(self, key, cas=0):
        
        server = self._get_server(key)
        return server.delete(key, cas)
1141903
def remove_block(self, name):
        

        if not self._ast or not name in self._block_map:
            raise ValueError(u"Block '{0}' does not exist"
                             .format(common.from_utf8(name)))

        block_idx = self._block_map[name]

        # remove block
        self._ast[2].pop(block_idx)
        del self._block_map[name]
491021
def pop(self, key, default=None):
        
        return self._dictionary.pop(key.lower(), default)
676089
def delete(self, key):
        
        with self._lmdb.begin(write=True, buffers=True) as txn:
            txn.delete(key.encode())
1007783
def remove(self, key):
        
        payload = {
            key: {
                '__op': 'Delete'
                }
            }
        self.__class__.PUT(self._absolute_url, **payload)
        del self.__dict__[key]
870986
def remove_lock(lock, key, session=None):
    
    return _request('get', '/remove/lock/{0}'.format(lock), params={'key': key}, session=session)
199529
def remove(self, key):
        '''
        
        '''
        encodedKey = json.dumps(key)
        sql = 'DELETE FROM ' + self.table + ' WHERE name = %s'
        with self.connect() as conn:
            with doTransaction(conn):
                return executeSQL(conn, sql, args=[encodedKey])
846371
public void remove(String key) {
        String processedKey = processKey(key);
        String orderKey = null;

        // removing key set for all positions
        for (int i = 0; i < this.order.size(); i++) {
            orderKey = this.order.get(i);

            if (orderKey != null && orderKey.equals(processedKey) == true) {
                this.order.remove(i);
            }
        }

        this.types.remove(processedKey);
        this.direction.remove(processedKey);
        this.values.remove(processedKey);
    }