Removes an item from ListNode.

        Raises:
            TypeError: If it's called on container ListNode (intstead of ListNode's item)

        Note:
            Parent object should be explicitly saved.
168481
def remove(self):
        
        if not self._is_item:
            raise TypeError("Should be called on an item, not ListNode's itself.")
        self.container.node_stack.remove(self)
382627
def remove(self, pk):
        
        pk = str(pk)
        try:
            del self.items[pk]
        except KeyError:
            raise ItemNotInCart(pk=pk)
        self.update()
738953
def remove(self, item):
        ''''''
        score = self._dict.pop(item, None)
        if score is not None:
            self._sl.remove(score)
            return score
796111
def delete_node(self, node: str):
        
        if self.has_node(node):
            self.remove_node(node)
377069
def on_remove(self, widget, data=None):
        
        treeiter, path = self.get_selected_object()
        if not treeiter:
            return

        # check if an element is selected
        dict_path_as_list = self.tree_store[path][self.ID_STORAGE_ID]
        logger.debug("Deleting semantic data entry with name {}!".format(dict_path_as_list[-1]))
        self.model.state.remove_semantic_data(dict_path_as_list)
        self.reload_tree_store_data()

        # hold cursor position where the last element was removed
        try:
            self.select_entry(self.tree_store[path][self.ID_STORAGE_ID])
        except IndexError:
            if len(self.tree_store):
                if len(path) > 1:
                    possible_before_path = tuple(list(path[:-1]) + [path[-1] - 1])
                    if possible_before_path[-1] > -1:
                        self.select_entry(self.tree_store[possible_before_path][self.ID_STORAGE_ID])
                    else:
                        self.select_entry(self.tree_store[path[:-1]][self.ID_STORAGE_ID])
                else:
                    self.select_entry(self.tree_store[path[0] - 1][self.ID_STORAGE_ID])
        return True
982253
def popitem(self):
        
        node = self._head[2]
        if node is self._tail:
            raise KeyError('list is empty')
        self._find_lt(node[0])
        self._remove(node)
        return (node[0], node[1])
1351562
int deleteElement(int list, int node) {
		int prev = getPrev(node);
		int next = getNext(node);
		if (prev != nullNode())
			setNext_(prev, next);
		else
			m_lists.setField(list, 0, next);// change head
		if (next != nullNode())
			setPrev_(next, prev);
		else
			m_lists.setField(list, 1, prev);// change tail

		freeNode_(node);
		setListSize_(list, getListSize(list) - 1);
		return next;
	}
1066587
def _close_list(self):
        
        list_type = self.current_parent_element['attrs']['class']
        tag = LIST_TYPES[list_type]

        html = '</{t}>'.format(
            t=tag
        )
        self.cleaned_html += html
        self.current_parent_element['tag'] = ''
        self.current_parent_element['attrs'] = {}
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
16516
def remove(self, child):
        ''''''
        try:
            self.children.remove(child)
            if isinstance(child, String):
                child._parent = None
        except ValueError:
            pass
409340
def pop(self, key, default=NONE):
        
        if key in self:
            self._list_remove(key)
            return self._pop(key)
        else:
            if default is NONE:
                raise KeyError(key)
            else:
                return default
1289466
def remove_child(self, widget):
        
        raw = list(filter(lambda x: x[0] == widget, self._items))
        if raw:
            itm, wrapped = raw[0]
            self._items.remove(raw[0])
            super(List, self).remove_child(wrapped)
        else:
            raise ValueError("Child not in list.")
934752
def remove_child(self, child):
        
        try:
            self._children.remove(child)
        except ValueError:  # Child may not be in list
            pass
        else:
            child.parent = None
929821
def remove(self, node, dirty=True):
        
        if node.id in self._children:
            self._children[node.id].parent = None
            del self._children[node.id]
        if dirty:
            self.touch()
716328
def dedent(self, node, dirty=True):
        
        if node.id not in self._subitems:
            return

        del self._subitems[node.id]
        node.super_list_item_id = None
        node.parent_item = None
        if dirty:
            node.touch(True)
1068979
function( item ) {
        $.console.assert(item, "[World.removeItem] item is required");

        var index = $.indexOf(this._items, item );
        if ( index === -1 ) {
            return;
        }

        item.removeHandler('bounds-change', this._delegatedFigureSizes);
        item.removeHandler('clip-change', this._delegatedFigureSizes);
        item.destroy();
        this._items.splice( index, 1 );
        this._figureSizes();
        this._needsDraw = true;
        this._raiseRemoveItem(item);
    }
193749
def remove_child(self, child):
        '''
        '''
        if not isinstance(child, Node):
            raise TypeError("child must be a Node")
        try:
            self.children.remove(child); child.parent = None
        except:
            raise RuntimeError("Attempting to remove non-existent child")