Remove the son node. Do nothing if the node is not a son

        Args:
            fathers: list of fathers to add
972414
def remove_son(self, son):
        
        self._sons = [x for x in self._sons if x.node_id != son.node_id]
127582
def deleted(self, src, path):
        """"""
        if self.parents[path] is not None:
            for parent in self.parents[path]:
                self.children[parent].remove(path)
                if not self.children[parent]:
                    del self.children[parent]
        del self.parents[path]
82906
def removeNode(self, node):
        
        ident = self.getIdent(node)
        if ident is not None:
            self.graph.hide_node(ident)
85386
function remove(node, isRemoveChild) {
  if (!node || !node.parentNode) { return; }
  if (node.removeNode) { return node.removeNode(isRemoveChild); }

  const parent = node.parentNode;
  if (!isRemoveChild) {
    const nodes = [];
    for (let i = 0, len = node.childNodes.length; i < len; i++) {
      nodes.push(node.childNodes[i]);
    }

    for (let i = 0, len = nodes.length; i < len; i++) {
      parent.insertBefore(nodes[i], node);
    }
  }

  parent.removeChild(node);
}
16516
def remove(self, child):
        ''''''
        try:
            self.children.remove(child)
            if isinstance(child, String):
                child._parent = None
        except ValueError:
            pass
73422
def drop(self):
        
        if self.is_root:
            raise ValueError("Cannot drop root node!")

        parent = self.parent
        for child in self.children:
            child.parent = parent
            parent.children.add(child)
        self.children = set()

        parent.sequence_ids.update(self.sequence_ids)
        self.sequence_ids = set()

        parent.remove_child(self)
707473
def remove_unnecessary_self_time_nodes(frame, options):
    '''
    
    '''
    if frame is None:
        return None

    if len(frame.children) == 1 and isinstance(frame.children[0], SelfTimeFrame):
        child = frame.children[0]
        frame.self_time += child.self_time
        child.remove_from_parent()
    
    for child in frame.children:
        remove_unnecessary_self_time_nodes(child, options=options)
    
    return frame
254582
def add_node(node, parent):
    '''
    '''
    newNode = dict(node_id=node.id, children=[])
    parent["children"].append(newNode)
    if node.left: add_node(node.left, newNode)
    if node.right: add_node(node.right, newNode)
49445
def move(self, new_father, idx=None, prepend=None, name=None):
        """"""
        self.parent.pop(self._own_index)
        new_father._insert(self, idx=idx, prepend=prepend, name=name)
        new_father._stable = False
        return self
561286
def remove_xml_element(name, tree):
    
    # root = tree.getroot()
    remove = tree.findall(
        ".//{{http://soap.sforce.com/2006/04/metadata}}{}".format(name)
    )
    if not remove:
        return tree

    parent_map = {c: p for p in tree.iter() for c in p}

    for elem in remove:
        parent = parent_map[elem]
        parent.remove(elem)

    return tree
1354689
def remove(self, *args):
        
        for x in args:
            self.children.remove(x)
        return self.children
1259661
public void remove(Node node) {
    if (node==null) return;
    if( node instanceof InnerNode ) {
      throw new IllegalArgumentException(
        "Not allow to remove an inner node: "+NodeBase.getPath(node));
    }
    LOG.info("Removing a node: "+NodeBase.getPath(node));
    netlock.writeLock().lock();
    try {
      String currentRackName = node.getNetworkLocation();
      if (clusterMap.remove(node)) {
        InnerNode rack = (InnerNode)getNode(node.getNetworkLocation());
        if (rack == null) {
          if (!racks.remove(currentRackName)) {
            LOG.error("Discrepancy between network topology and list of racks. "
                + "Removed rack "
                + currentRackName
                + " was not in the rack list.");
          }
        }
      }
      LOG.debug("NetworkTopology became:\n" + this.toString());
    } finally {
      netlock.writeLock().unlock();
    }
  }
994916
def removeChild(self, child):
		
		for i, childNode in enumerate(self.childNodes):
			if childNode is child:
				del self.childNodes[i]
				child.parentNode = None
				return child
		raise ValueError(child)
745157
function remove(node) {
    var next = node.nextSibling || node.parentNode;

    node.parentNode.removeChild(node);

    return next;
}
564402
def remove(parent, idx):
  """"""
  if isinstance(parent, dict):
    del parent[idx]
  elif isinstance(parent, list):
    del parent[int(idx)]
  else:
    raise JSONPathError("Invalid path for operation")
783347
def _disconnect_parent(self, *args, **kw):
        
        for name, iop in list(self._index_operations.items()):
            iopc = iop.copy()
            iop.clear()
            self.remove_index_operation(name)
            self.add_index_operation(name, iopc)
        #self.constraints.clear()
        #self.constraints = constr
        self._parent_ = None
        self._parent_index_ = None
        self._connect_fixes()
        self._notify_parent_change()
16108
function removeNotNeededNodes(parentElements, newChildren, oldChildren) {
  let remaining = parentElements.childNodes.length;
  if (oldChildren.length !== remaining) {
    console.warn(
      "ZLIQ: Something other then ZLIQ has manipulated the children of the element",
      parentElements,
      ". This can lead to sideffects. Consider using the 'isolated' attribute for this element to prevent updates."
    );
  }

  for (; remaining > newChildren.length; remaining--) {
    let childToRemove = parentElements.childNodes[remaining - 1];
    parentElements.removeChild(childToRemove);

    if (oldChildren.length < remaining) {
      continue;
    } else {
      let { cycle } = oldChildren[remaining - 1];

      triggerLifecycle(childToRemove, { cycle }, "removed");
    }
  }
}