Delete an object.
543823
def delete(self, robj, rw=None, r=None, w=None, dw=None, pr=None, pw=None,
               timeout=None):
        
        # We could detect quorum_controls here but HTTP ignores
        # unknown flags/params.
        params = {'rw': rw, 'r': r, 'w': w, 'dw': dw, 'pr': pr, 'pw': pw,
                  'timeout': timeout}
        headers = {}

        bucket_type = self._get_bucket_type(robj.bucket.bucket_type)

        url = self.object_path(robj.bucket.name, robj.key,
                               bucket_type=bucket_type, **params)
        use_vclocks = (self.tombstone_vclocks() and hasattr(robj, 'vclock') and
                       robj.vclock is not None)
        if use_vclocks:
            headers['X-Riak-Vclock'] = robj.vclock.encode('base64')
        response = self._request('DELETE', url, headers)
        self.check_http_code(response[0], [204, 404])
        return self
1301143
def delete(self, del_objects=False):
        
        return self.manager.delete(self, del_objects=del_objects)
626295
function cleanObject(obj) {
  if (obj instanceof Object) {
    Object.keys(obj).forEach((key) => (obj[key] == null) && delete obj[key]);
  }
  return obj;
}
841640
def delete(cls, **kwargs):
        '''
        
        '''
        q = cls._get_instance(**kwargs)
        if q:
            _action_and_commit(q, session.delete)
928522
def remove_object(self, object=0, delete=True):
        
        if type(object) in [int, int]: n = object
        else:                           n = self.objects.index(object)

        # pop it from the list
        object = self.objects.pop(n)

        # remove it from the GUI and delete it
        if hasattr_safe(object, '_widget'):
            self._layout.removeWidget(object._widget)
            object._widget.hide()
            if delete: object._widget.deleteLater()
        else:
            self._layout.removeWidget(object)
            object.hide()
            if delete: object.deleteLater()
1261950
def _remove(self, obj):
        """"""
        for idx, item in enumerate(self._queue):
            if item == obj:
                del self._queue[idx]
                break
598194
def delete(self, key):
        """"""
        self._get_table()
        self.table.delete_item(key=key)
        log.debug("Deleted item at key '%s'" % (key))
174405
def delete(self):
        
        with rconnect() as conn:
            # Can't delete an object without an ID.
            if self.id is None:
                raise FrinkError("You can't delete an object with no ID")
            else:
                if isinstance(self.id, uuid.UUID):
                    self.id = str(self.id)

                try:
                    query = r.db(
                        self._db
                    ).table(
                        self._table
                    ).get(
                        self.id
                    ).delete()
                    log.debug(query)
                    rv = query.run(conn)
                except Exception as e:
                    log.warn(e)
                    raise
                else:
                    return True
610743
function remove(object, key){
  utils.assertType(object, 'object', 'object');
  utils.assertString(key, 'key');
  delete object.vals[key.string];
  return object;
}
1302655
def delete(cls, id, api_key=None, **kwargs):
        """"""
        inst = cls(api_key=api_key)
        endpoint = '/'.join((cls.get_endpoint(), id))
        inst.request('DELETE', endpoint=endpoint, query_params=kwargs)
        inst._is_deleted = True
        return True
1361339
function(obj, fn) {
		for (var key in obj) {
			if (fn(obj[key], key)) delete obj[key];
		}

		return obj;
	}
315061
public void remove(@NonNull T object) {
        synchronized (mLock) {
            final int position = getPosition(object);
            final boolean removed = mObjects.remove(object);
            if (removed) {
                notifyItemRemoved(position);
            }
        }

    }
151629
def RemoveObject(self, path):
        '''
        '''
        try:
            objects[path].remove_from_connection()
            del objects[path]
        except KeyError:
            raise dbus.exceptions.DBusException(
                'object %s does not exist' % path,
                name='org.freedesktop.DBus.Mock.NameError')
732098
def delete(self, name):
        """"""
        obj = self._get_object(name)
        if obj:
            return self.driver.delete_object(obj)
1009436
def delete_object(self, obj, post_delete=False):
        
        # Collect related objects that will be deleted by cascading
        links = [rel.get_accessor_name() for rel in \
                 obj._meta.get_all_related_objects()]
        # Recursively delete each of them
        for link in links:
            objects = getattr(obj, link).all()
            for o in objects:
                self.delete_object(o, post_delete)
        # Delete the actual object
        self._delete_object(obj, post_delete)
156580
function del(obj, key, immutable) {
    if (immutable)
        return _del(assign({}, obj), key);
    return _del(obj, key);
}
1191927
def delete(self, obj):
        """"""
        del_id = obj.get_id()
        if not del_id:
            return

        coll = self.get_collection(obj.__class__.get_table_name())
        coll.delete_one({"_id": del_id})