Delete the required resource.
503746
def remove(cls, resource_id, parent_id=None, grandparent_id=None,
               wait=True, timeout=None):
        """"""
        raise exception.NotSupported(feature="DELETE",
                                     context="VirtualSwitchManager")
774880
def delete(self, request, **resources):
        

        resource = resources.get(self._meta.name)
        if not resource:
            raise HttpError("Bad request", status=status.HTTP_404_NOT_FOUND)

        for o in as_tuple(resource):
            o.delete()

        return HttpResponse("")
1204837
def delete_resource(self, resource_path):
        
        res = self.execute_operation(method="DELETE", ops_path=resource_path)
        logging.info("Deleted resource %s" %(resource_path))
        return res
1066571
def delete(self, params, args, data):
        """"""
        ctx = self._create_context(params, args, data)
        row_id = ctx.get_row_id()

        if row_id:
            deleted = self._delete_one(row_id, ctx)

            if deleted:
                return ResourceResult(body={})
            else:
                return NOT_FOUND
        else:
            return NOT_FOUND
677838
def delete(self):
        """"""
        self._client.remove_object(self._instance, self._bucket, self.name)
1148171
def release(self):
        
        if self.errored:
            self.pool.delete_resource(self)
        else:
            self.pool.release(self)
496075
def remove_resources(self, resources):
    

    resources_to_delete = self._build_resource_dictionary(resources)
    for email in resources_to_delete.keys():
      if email in self._resources:
        del self._resources[email]

    self._dirty_attributes.add(u'resources')
817084
def delete(self):
        
        _, r = self.machine.datacenter.request('DELETE', self.path)
        r.raise_for_status()
88440
def delete(method, hmc, uri, uri_parms, logon_required):
        """"""
        try:
            resource = hmc.lookup_by_uri(uri)
        except KeyError:
            raise InvalidResourceError(method, uri)
        resource.manager.remove(resource.oid)
1087377
def delete(self):
        
        resp = self.r_session.delete(self.database_url)
        resp.raise_for_status()
143225
def delete_resource(resource_id):
    """"""
    resource_obj = app.db.resource(resource_id)
    try:
        os.remove(resource_obj.path)
    except OSError as err:
        app.logger.debug(err.message)

    app.db.delete_resource(resource_id)
    return redirect(request.referrer)
455947
def delete(self) :
        """"""
        r = self.connection.session.delete(self.URL)
        data = r.json()
        if not r.status_code == 200 or data["error"] :
            raise DeletionError(data["errorMessage"], data)
402542
def delete(self, service_name, *ids, **kwargs):
        """"""
        return self._send(requests.delete, service_name, id=ids, **kwargs)
890978
def delete(self, resource, rid=None):  # note that rid can't be 0 - problem?
        
        if rid:
            if resource[-1] != '/':
                resource += '/'
            resource += str(rid)
        response = self._run_method('DELETE', resource)
        return self._handle_response(resource, response, suppress_empty=True)
1330025
def delete(resource_uri)
      connection.delete("resource") do |request|
        request.query[:uri] = resource_uri.to_s
        request.query.delete(:graph)
      end
    end
1101068
def delete(self):
        ''
        #url = '%s?dl=true' % self.path
        r = self.jfs.post(url=self.path, params={'dl':'true'})
        return r
499060
def delete(self):
        """"""
        response = self.http_request(self._url, 'DELETE')
        if response.status != 204:
            self.raise_http_error(response)