DELETE an object.

    Note: No payload argument is supported.
186756
def delete_object_async(self, path, **kwds):
    
    return self.do_request_async(self.api_url + path, 'DELETE', **kwds)
74418
def delete_cloud_obj(self, cloud_obj):
        
        self._connection.delete_object(
            container=self.container_name,
            obj=cloud_obj,
        )
594628
def delete(self, obj, id):
        
        self.url = '{}{}/{}'.format(self.base_url, obj, id)
        self.method = 'DELETE'
        self.resp = requests.delete(url=self.url,
                                    auth=self.auth,
                                    headers=self.headers, cert=self.ca_cert)
        return self.__process_resp__(obj)
1091979
function(obj, key) {
		var value;
		for (var i = 2; i < arguments.length; i++) {
			value = arguments[i];
			if (value !== undefined) {
				obj[key] = value;
				break;
			}
		}

		if (value === undefined) delete obj[key];

		return obj;
	}
1354438
def delete_object(self, obj):
        
        session = self.get_db_session()
        session.delete(obj)
        session.commit()
1261950
def _remove(self, obj):
        """"""
        for idx, item in enumerate(self._queue):
            if item == obj:
                del self._queue[idx]
                break
344483
def delete_object(objectID, request_options = {})
      raise ArgumentError.new('objectID must not be blank') if objectID.nil? || objectID == ''
      client.delete(Protocol.object_uri(name, objectID), :write, request_options)
    end
1207863
def delete(self, obj):
        """"""
        del_id = obj.get_id()
        if not del_id:
            return

        cur = self._conn().cursor()

        tabname = obj.__class__.get_table_name()
        query = 'delete from %s where id = ?' % tabname
        cur.execute(query, (del_id,))

        self._conn().commit()
        cur.close()
1099769
def _delete(self, *args, **kwargs):
        
        response = requests.delete(*args, **kwargs)
        response.raise_for_status()
184345
def delete_object(connection, container: str, object_meta_data: dict) -> None:
    
    connection.delete_object(container, object_meta_data['name'])
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()
695832
def delete(self):
        """"""
        check_bind(self)
        if self.id is None:
            raise ServerError("{} object does not exist yet".format(self.__class__.name))
        elif not self.__class__._has_schema_method("destroy"):
            raise MethodNotSupported("{} do not support deletion.".format(self.__class__.__name__))

        try:
            self._resource.delete()
        except HTTPError as e:
            if e.response.status_code == 403:
                raise PermissionDenied("")  # FIXME: is this right?
            else:
                raise e
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
823042
def delete_object(self, cont, obj):
        '''
        
        '''
        try:
            self.conn.delete_object(cont, obj)
            return True
        except Exception as exc:
            log.error('There was an error::')
            if hasattr(exc, 'code') and hasattr(exc, 'msg'):
                log.error('    Code: %s: %s', exc.code, exc.msg)
            log.error('    Content: \n%s', getattr(exc, 'read', lambda: six.text_type(exc))())
            return False
1166533
def delete_object(self, object):
        
        #pdb.set_trace()
        self.db.engine.delete_key(object)#, userid='abc123', id='1')
        print('dynamo.delete_object(%s)' % object)
156580
function del(obj, key, immutable) {
    if (immutable)
        return _del(assign({}, obj), key);
    return _del(obj, key);
}
42069
def _remove(self, client_kwargs):
        
        with _handle_oss_error():
            bucket = self._get_bucket(client_kwargs)

            # Object
            if 'key' in client_kwargs:
                return bucket.delete_object(key=client_kwargs['key'])

            # Bucket
            return bucket.delete_bucket()