Delete items in model.
961378
def delete(self, layer, items):
        
        # Use edit to get the layer obj containing item
        items = _listify(items)  # make items a list if it's not
        layer_obj = self.edit(layer, dict.fromkeys(items), delete=True)
        for k in items:
            if k in layer_obj.layer:
                layer_obj.delete(k)
            else:
                raise AttributeError('item %s missing from layer %s' %
                                     (k, layer))
836227
def remove(self, items):
        """"""
        with _presub_lock:
            self.load_from_cloud()
            for entry in utils.ensure_listable(items):
                # remove all matching entries
                while entry in self.current:
                    self.current.remove(entry)
            self.save_to_cloud()
679859
def delete(self):
        """"""
        if not self.id:
            return
        self.collection.remove({'_id': self._id})
        self.on_delete(self)
387
def delete(self, id):
        ''''''
        if not self._item_path:
            raise AttributeError('delete is not available for %s' % self._item_name)
        target = self._item_path % id
        self._redmine.delete(target)
        return None
963469
def remove(self, x):
        """"""

        def _remove(x):
            found = self.first(x)
            if found is not None:
                self._args.pop(found)

        if _is_collection(x):
            for item in x:
                _remove(x)
        else:
            _remove(x)
819903
public void clear() {
        List<?> items = getChildren();
        
        for (int i = items.size() - 1; i >= 0; i--) {
            if (items.get(i) != customItem) {
                items.remove(i);
            }
        }
    }
777349
def _reset_model(self, table, model):
        """"""
        old_sel_model = table.selectionModel()
        table.setModel(model)
        if old_sel_model:
            del old_sel_model
163634
function() {
                    can.Model._reqs--;
                    // Don't clean up unless we have no pending requests.
                    if (!can.Model._reqs) {
                        for (var id in this.store) {
                            // Delete all items in the store without any event bindings.
                            if (!this.store[id]._bindings) {
                                delete this.store[id];
                            }
                        }
                    }
                    return arguments[0];
                }
333750
def delete_item(self, item):
        '''  '''
        for relation, dst in self.relations_of(item, True):
            self.delete_relation(item, relation, dst)
            #print(item, relation, dst)
        for src, relation in self.relations_to(item, True):
            self.delete_relation(src, relation, item)
            #print(src, relation, item)
        h = self._item_hash(item)
        if item in self:
            #print('deleting item:', item)
            self.nodes[h].clear()
            del self.nodes[h]
1345186
def clear(self):
        
        model = self.tree.model()
        # Don't use model.clear(). it will delete the column sizes
        model.removeRows(0, 1)
        model.setRowCount(1)
        self._setColumnCountForContents()
211463
def remove(self, items):
        """"""
        items = coerce_to_list(items)
        new_options = {k: v for k, v in self.options.items() if v not in items}
        self.widget.options = new_options
        self.widget.param.trigger('options')
957142
def remove_obsolete_items(self):
        """"""
        self.rdata = [(filename, data) for filename, data in self.rdata
                      if is_module_or_package(filename)]
400090
def remove(self, models):
        
        models = self._check_model_types(models)
        for model in models:
            if model in self._selected:
                self._selected.remove(model)
147563
public function removeAll()
    {
        foreach ($this->_associated_objects as $parent_property => $object) {
            /**
             * @var Model
             */
            $object->setDirty($parent_property);
        }
        $this->exchangeArray([]);
    }
682625
def delete(self, item, dry_run=None):
        """"""
        logger.debug('Deleting item. Item: {item} Table: {namespace}'.format(
            item=item,
            namespace=self.namespace
        ))

        if not dry_run:
            self.table.delete_item(Key={'id': item['id']})

        return item
922971
def cleanup(self):
        """"""
        expires = maybe_timedelta(self.expires)
        for model in self.TaskModel, self.TaskSetModel:
            model._default_manager.delete_expired(expires)
1261950
def _remove(self, obj):
        """"""
        for idx, item in enumerate(self._queue):
            if item == obj:
                del self._queue[idx]
                break