Requests to delete a node by the given key.
511436
def delete(self, key, dir=False, recursive=False,
               prev_value=None, prev_index=None, timeout=None):
        """"""
        url = self.make_key_url(key)
        params = self.build_args({
            'dir': (bool, dir or None),
            'recursive': (bool, recursive or None),
            'prevValue': (six.text_type, prev_value),
            'prevIndex': (int, prev_index),
        })
        try:
            res = self.session.delete(url, params=params, timeout=timeout)
        except:
            self.erred()
        return self.wrap_response(res)
158405
def delete_metadata_for_node(self, node, keys=None):
        
        return self.manager.delete_metadata(self, keys=keys, node=node)
518239
def remove(self, key):
        """"""
        item = self.item_finder.pop(key)
        item[-1] = None
        self.removed_count += 1
796111
def delete_node(self, node: str):
        
        if self.has_node(node):
            self.remove_node(node)
557498
function (key) {
            var self = this;
            parseQuery(self);
            if (key) {
                delete self._queryMap[key];
            } else {
                self._queryMap = {};
            }
            return self;

        }
1291792
public synchronized void remove(Object key)
	{
		final Object o = map.remove(key);
		if (o != null)
			tree.remove(o);
	}
540171
def delete_node(self, node_id):
        """"""
        node = self.get_node(node_id)

        # Remove all edges from the node
        for e in node['edges']:
            self.delete_edge_by_id(e)

        # Remove all edges to the node
        edges = [edge_id for edge_id, edge in list(self.edges.items()) if edge['vertices'][1] == node_id]
        for e in edges:
            self.delete_edge_by_id(e)

        # Remove the node from the node list
        del self.nodes[node_id]

        self._num_nodes -= 1
636073
def delete(self, key=None):
        """"""

        # Delete the whole bucket.
        if key is None:
            # Delete everything in the bucket.
            for key in self.all():
                key.delete()

            # Delete the bucket.
            return self._boto_bucket.delete()

        # If a key was passed, delete they key.
        k = self.key(key)
        return k.delete()
730012
def delete_node(self, root, key):
        
        if not root: return None

        if root.val == key:
            if root.left:
                # Find the right most leaf of the left sub-tree
                left_right_most = root.left
                while left_right_most.right:
                    left_right_most = left_right_most.right
                # Attach right child to the right of that leaf
                left_right_most.right = root.right
                # Return left child instead of root, a.k.a delete root
                return root.left
            else:
                return root.right
        # If left or right child got deleted, the returned root is the child of the deleted node.
        elif root.val > key:
            root.left = self.deleteNode(root.left, key)
        else:
            root.right = self.deleteNode(root.right, key)
        return root
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])
36905
public void remove(int key) {
        int i = binarySearch(mKeys, 0, mSize, key);
        if (i >= 0 && mValues[i] != DELETED) {
            mValues[i] = DELETED;
            mGarbage = true;
        }
    }
1214948
def delete(self, key):
    '''
    '''
    self.cache_datastore.delete(key)
    self.child_datastore.delete(key)
784421
def del_key(self, key, key_to_delete):
        ""
        v = self.get(key)
        if key_to_delete in v:
            del v[key_to_delete]
            self.set(key, v)
490317
public void removeByKey(Object key)
    {
        Object value = keyTable.remove(key);
        if (value != null)
        {
            valueTable.remove(value);
        }
    }
752365
def delete(self, key):
        """"""
        if not self.debug:
            self.database.delete(self.make_key(key))
1244266
def delete_node(self, key_chain):
        
        node = self._data
        for key in key_chain[:-1]:
            node = node[key]

        del node[key_chain[-1]]
476541
def remove(self, key):
        
        self._find_lt(key)
        node = self._path[0][2]
        if node is self._tail or key < node[0]:
            raise KeyError('{!r} is not in list'.format(key))
        self._remove(node)