Sends a DELETE request for this object
334343
def delete(self):
        
        resp = self._client.delete(type(self).api_endpoint, model=self)

        if 'error' in resp:
            return False
        self.invalidate()
        return True
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
46449
def _delete(self, url):
        """"""
        req = self._session.delete(self._api_prefix + url)
        return self._action(req)
1038500
public DeleteResponse delete(DeleteRequest request) throws IOException {
        return new DeleteResponse(client.doDelete(request.toUrl()));
    }
841640
def delete(cls, **kwargs):
        '''
        
        '''
        q = cls._get_instance(**kwargs)
        if q:
            _action_and_commit(q, session.delete)
815001
def delete(self, json=None):
        
        return self._call('delete', url=self.endpoint, json=json)
426093
def delete(self, service, path, **kwargs):
        
        return self.make_request(Methods.DELETE, service, path, **kwargs)
158178
def delete(self):
        
        self._requester.requestJsonAndCheck(
            "DELETE",
            self._parentUrl("") + "/reactions/" + str(self.id),
            headers={'Accept': Consts.mediaTypeReactionsPreview}
        )
1369670
public function delete()
    {
        $this->_user->post('push/delete', array('id' => $this->getId()));
        // The delete API call doesn't return the object, so set the status
        // manually
        $this->_status = self::STATUS_DELETED;
    }
6897
def _create_delete_request(self, resource, billomat_id):
        
        assert (isinstance(resource, str))

        if isinstance(billomat_id, int):
            billomat_id = str(billomat_id)

        response = self.session.delete(
            url=self.api_url + resource + '/' + billomat_id,
        )

        return self._handle_response(response)
25821
def delete(self, space_no, *args):
        
        d = self.replyQueue.get()
        packet = RequestDelete(self.charset, self.errors, d._ipro_request_id, space_no, 0, *args)
        self.transport.write(bytes(packet))
        return d.addCallback(self.handle_reply, self.charset, self.errors, None)
962162
def delete(query_url,
               headers: {},
               parameters: {})
      HttpRequest.new(HttpMethodEnum::DELETE,
                      query_url,
                      headers: headers,
                      parameters: parameters)
    end
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
534241
def delete(self, id):
        
        url = self._url('%s' % (id))
        return self.client.delete(url)
575815
def delete(self, request, id):
        
        if not id:
            # can't delete the whole container
            raise errors.MethodNotAllowed()
        try:
            models.User.objects.get(pk=id).delete()
        except models.User.DoesNotExist:
            # we never had it, so it's definitely deleted
            pass
37324
def delete(self, path, callback=None, timeout=None, **kwargs):  # pragma: no cover
        
        request = self.mk_request(defines.Codes.DELETE, path)

        for k, v in kwargs.items():
            if hasattr(request, k):
                setattr(request, k, v)

        return self.send_request(request, callback, timeout)
499060
def delete(self):
        """"""
        response = self.http_request(self._url, 'DELETE')
        if response.status != 204:
            self.raise_http_error(response)