Identical to __delitem__, but returns whether a member was removed.
351944
def remove(self, member):
        
        if member not in self:
            return False
        score = self._members[member]
        score_index = bisect_left(self._scores, (score, member))
        del self._scores[score_index]
        del self._members[member]
        return True
802045
function handleRemovedConfigItems(_a) {
    var fileInitialState = _a.fileInitialState, memoryInitialState = _a.memoryInitialState;
    var removedItems = memoryInitialState.filter(function (bsItem) {
        var removedItem = !fileInitialState.find(function (fileItem) { return bsItem.key === fileItem.key; });
        return removedItem;
    });
    if (removedItems.length > 0) {
        console.log('REMOVED CONFIG: ', removedItems);
    }
    removedItems.forEach(function (removedItem) {
        removeItemFromBrowserStorage(removedItem);
    });
}
1062214
public boolean remove(ESigItem item) {
        boolean result = items.remove(item);
        
        if (result) {
            removed(item);
        }
        
        return result;
    }
989182
def delete_items_from_dict(d, to_delete):
    
    if not isinstance(to_delete, list):
        to_delete = [to_delete]
    if isinstance(d, dict):
        for single_to_delete in set(to_delete):
            if single_to_delete in d.values():
                for k, v in d.copy().items():
                    if v == single_to_delete:
                        del d[k]
        for k, v in d.items():
            delete_items_from_dict(v, to_delete)
    elif isinstance(d, list):
        for i in d:
            delete_items_from_dict(i, to_delete)
    return remove_none(d)
346672
def removeLT(self, item):
        """"""
        count = self.getCountLT(item)
        self._list = self._list[count:]
        return count
80306
def delete(self, item):
        
        indexer = self.items.get_loc(item)

        is_deleted = np.zeros(self.shape[0], dtype=np.bool_)
        is_deleted[indexer] = True
        ref_loc_offset = -is_deleted.cumsum()

        is_blk_deleted = [False] * len(self.blocks)

        if isinstance(indexer, int):
            affected_start = indexer
        else:
            affected_start = is_deleted.nonzero()[0][0]

        for blkno, _ in _fast_count_smallints(self._blknos[affected_start:]):
            blk = self.blocks[blkno]
            bml = blk.mgr_locs
            blk_del = is_deleted[bml.indexer].nonzero()[0]

            if len(blk_del) == len(bml):
                is_blk_deleted[blkno] = True
                continue
            elif len(blk_del) != 0:
                blk.delete(blk_del)
                bml = blk.mgr_locs

            blk.mgr_locs = bml.add(ref_loc_offset[bml.indexer])

        # FIXME: use Index.delete as soon as it uses fastpath=True
        self.axes[0] = self.items[~is_deleted]
        self.blocks = tuple(b for blkno, b in enumerate(self.blocks)
                            if not is_blk_deleted[blkno])
        self._shape = None
        self._rebuild_blknos_and_blklocs()
965058
def remove_all(self, item):
        # type: (Any) -> None
        
        item = self.ref(item)
        while list.__contains__(self, item):
            list.remove(self, item)
271599
def lastIndexOf(self, item):
        
        array = self.obj
        i = len(array) - 1
        if not (self._clean.isList() or self._clean.isTuple()):
            return self._wrap(-1)

        while i > -1:
            if array[i] is item:
                return self._wrap(i)
            i -= 1
        return self._wrap(-1)
424485
def delete_list_items(list_, item_list, copy=False):
    
    """
    if copy:
        list_ = list_[:]
    for item in item_list:
        list_.remove(item)
    return list_
382627
def remove(self, pk):
        
        pk = str(pk)
        try:
            del self.items[pk]
        except KeyError:
            raise ItemNotInCart(pk=pk)
        self.update()
479779
def removeItem( self ):
        
        item = self.uiMenuTREE.currentItem()
        if ( not item ):
            return
        
        opts = QMessageBox.Yes | QMessageBox.No
        answer = QMessageBox.question( self,
                                       'Remove Item',
                                       'Are you sure you want to remove this '\
                                       ' item?',
                                       opts )
        
        if ( answer == QMessageBox.Yes ):
            parent = item.parent()
            if ( parent ):
                parent.takeChild(parent.indexOfChild(item))
            else:
                tree = self.uiMenuTREE
                tree.takeTopLevelItem(tree.indexOfTopLevelItem(item))
1270090
def match(self, item):
        
        val = getattr(item, self._name) or False
        return bool(val) is self._value
1347616
def one_item(self, item, detach:bool=False, denorm:bool=False, cpu:bool=False):
        ""
        ds = self.single_ds
        with ds.set_item(item):
            return self.one_batch(ds_type=DatasetType.Single, detach=detach, denorm=denorm, cpu=cpu)
1057597
def popitem(self, last=True):
		
		try:
			if last:
				key, value = self._list.pop()
				index = len(self._list)
			else:
				key, value = self._list.pop(0)
				index = 0
		except IndexError:
			raise KeyError("IndexedDict is empty")

		index2, value2 = self._dict.pop(key)
		assert index == index2
		assert value is value2

		if not last:
			self._fix_indices_after_delete()

		return key, value
471984
def refs_equal(olditem, newitem):
        
        oldrefs = olditem.references
        newrefs = newitem.references

        ref_equal = lambda oldref, newref: True if (len(oldref) == len(newref)) and all(
            x in oldref for x in newref) else False
        if len(oldrefs) == len(newrefs) and all(
                any(ref_equal(oldref, newref) for oldref in oldrefs) for newref in newrefs):
            return True
        else:
            return False
738953
def remove(self, item):
        ''''''
        score = self._dict.pop(item, None)
        if score is not None:
            self._sl.remove(score)
            return score
275730
def remove(self, cls, originalMemberNameList, memberName, classNamingConvention):
        
        accessorDict = self._accessorDict(memberName, classNamingConvention)
        for accessorName, _ in accessorDict.items():
            if accessorName not in originalMemberNameList and hasattr(cls, accessorName):
                delattr(cls, accessorName)