Removes the node identified by node_id from the graph.
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
1366918
def remove_isolated_nodes(graph):
    
    nodes = list(nx.isolates(graph))
    graph.remove_nodes_from(nodes)
558071
def remove_network(self, net_id):
        
        url = self._url("/networks/{0}", net_id)
        res = self._delete(url)
        self._raise_for_status(res)
1029691
def remove_node(self, node):
        
        if _debug: Network._debug("remove_node %r", node)

        self.nodes.remove(node)
        node.lan = None
5228
def unlisten_to_node(self, id_):
        
        id_pubsub = _pubsub_key(id_)

        if id_pubsub in self._listening_to:
            del self._listening_to[id_pubsub]
            self.toredis.unsubscribe(id_pubsub)

            parent = json_decode(r_client.get(id_)).get('parent', None)
            if parent is not None:
                r_client.srem(_children_key(parent), id_)
            r_client.srem(self.group_children, id_)

            return id_
277889
def _del_tip(self, node_id):
        """"""
        self.nodes_deleted.append(node_id)
        etp = self._edge_by_target.get(node_id)
        assert etp is not None
        source_id, target_id = self._del_edge(etp)
        assert target_id == node_id
        return source_id
376137
def remove(self):
        
        if self.parent:
            for i, node in enumerate(self.parent.children):
                if node is self:
                    self.parent.changed()
                    del self.parent.children[i]
                    self.parent = None
                    return i
647354
def terminate_nodes(self, node_ids):
        """"""
        for node_id in node_ids:
            logger.info("NodeProvider: "
                        "{}: Terminating node".format(node_id))
            self.terminate_node(node_id)
911286
def remove(self, node):
        """"""
        if not isinstance(node, Node):
            raise TypeError('expecting Node instance')
        if node._list is None:
            return
        if node._list is not self:
            raise RuntimeError('node is not contained in list')
        if node._next is None:
            self._last = node._prev  # last node
        else:
            node._next._prev = node._prev
        if node._prev is None:
            self._first = node._next  # first node
        else:
            node._prev._next = node._next
        node._list = node._prev = node._next = None
        self._size -= 1
309071
def disconnect(self, node):
        
        rel = _rel_helper(lhs='a', rhs='b', ident='r', **self.definition)
        q = "MATCH (a), (b) WHERE id(a)={self} and id(b)={them} " \
            "MATCH " + rel + " DELETE r"
        self.source.cypher(q, {'them': node.id})
1092731
def del_graph(self, graph):
        """"""
        g = self.pack(graph)
        self.sql('del_edge_val_graph', g)
        self.sql('del_node_val_graph', g)
        self.sql('del_edge_val_graph', g)
        self.sql('del_edges_graph', g)
        self.sql('del_nodes_graph', g)
        self.sql('del_graph', g)
653683
def _clean(self):
        """"""
        found_ids = {}
        nodes = [self._nodes[_node.Root.ID]]
        while nodes:
            node = nodes.pop()
            found_ids[node.id] = None
            nodes = nodes + node.children

        for node_id in self._nodes:
            if node_id in found_ids:
                continue
            logger.error('Dangling node: %s', node_id)

        for node_id in found_ids:
            if node_id in self._nodes:
                continue
            logger.error('Unregistered node: %s', node_id)
949637
public void removeDatanode(DatanodeID nodeID)
    throws IOException {
    writeLock();
    try {
      DatanodeDescriptor nodeInfo = getDatanode(nodeID);
      if (nodeInfo != null) {
        removeDatanode(nodeInfo);
      } else {
        NameNode.stateChangeLog.warn("BLOCK* NameSystem.removeDatanode: "
          + nodeID.getName() + " does not exist");
      }
    } finally {
      writeUnlock();
    }
  }
887131
static function removeNode( $nodeID = 0 )
    {
        $node = eZContentObjectTreeNode::fetch( $nodeID );
        if ( !is_object( $node ) )
        {
            return;
        }

        return $node->removeThis();
    }
938733
def remove_vertex(u)
      u.clear_edges
      looked_up = self[u]
      # looked_up.successors.each do |succ|
      #   self[succ].remove_predecessor looked_up
      #   self[looked_up].delete_all_flags succ
      # end
      # looked_up.predecessors.each do |pred|
      #   self[pred].remove_successor looked_up
      #   self[pred].delete_all_flags looked_up
      # end
      @vertex_lookup.delete looked_up.name
      vertices.delete looked_up
    end
519272
def remove_allocated_node_name(self, name):
        

        if name in self._allocated_node_names:
            self._allocated_node_names.remove(name)
674503
def unlink(self, subj=None, predicate=None):
        
        self.graph.remove((subj, predicate, self.asNode()))