Make a delete requests (this returns a coroutine)
426093
def delete(self, service, path, **kwargs):
        
        return self.make_request(Methods.DELETE, service, path, **kwargs)
1134580
def delete(self, raise_exc=True, headers=None, files=None):
        ''''''

        return self._request(DELETE, None, raise_exc, headers, files)
1026218
def do_delete(endpoint, access_token):
    '''
    '''
    headers = {"Authorization": 'Bearer ' + access_token}
    headers['User-Agent'] = get_user_agent()
    return requests.delete(endpoint, headers=headers)
34317
def process_requests(self):
        
        while True:
            id, args, kwargs = self.request_queue.get()
            try:
                response = self._make_request(*args, **kwargs)
            except Exception as e:
                response = e
            self.results[id] = response
74818
def delete(self, endpoint, params=None, version='1.1', json_encoded=False):
        """"""
        return self.request(endpoint, 'DELETE', params=params, version=version, json_encoded=json_encoded)
921422
def dispatch(self, request, **kwargs):
        '''
        
        '''

        # Delete method must happen with POST not with GET
        if request.method == 'POST':
            # Check if this is a webservice request
            self.__authtoken = (bool(getattr(self.request, "authtoken", False)))
            self.json_worker = self.__authtoken or (self.json is True)
            # Call the base implementation
            return super(GenDelete, self).dispatch(request, **kwargs)
        else:
            json_answer = json.dumps({
                'error': True,
                'errortxt': _('Method not allowed, use POST to delete or DELETE on the detail url'),
                })
            return HttpResponse(json_answer, content_type='application/json')
402715
def _deleter(self, uri, headers):
        

        # perform Object HEAD request
        resp = self.http.delete(url=uri, headers=headers)
        self._resp_exception(resp=resp)
        return resp
1228695
def delete(self):
        
        return self._delete_request(endpoint=self.ENDPOINT + '/' + str(self.id))
459075
def delete_request(self, container, resource=None, query_items=None,
                       accept=None):
        """"""
        url = self.make_url(container, resource)
        headers = self._make_headers(accept)

        if query_items and isinstance(query_items, (list, tuple, set)):
            url += RestHttp._list_query_str(query_items)
            query_items = None

        try:
            rsp = requests.delete(url, params=query_items, headers=headers,
                                  verify=self._verify, timeout=self._timeout)
        except requests.exceptions.ConnectionError as e:
            RestHttp._raise_conn_error(e)

        if self._dbg_print:
            self.__print_req('DELETE', rsp.url, headers, None)

        return self._handle_response(rsp)
433072
def _delete_request(self, url, headers, data=None):
        
        return self._session.delete(url, headers=headers, data=data)
860597
async def remove(self, *args, **kwargs):
        

        return await self._makeApiCall(self.funcinfo["remove"], *args, **kwargs)
1054418
def delete(self, *args, **kwargs):
        
        return self.session.delete(*args, **self.get_kwargs(**kwargs))
815001
def delete(self, json=None):
        
        return self._call('delete', url=self.endpoint, json=json)
751964
def purge(self):
    """"""
    try:
      return self._api.purge()
    except AttributeError:
      while True:
        lst = self.list()
        if len(lst) == 0:
          break

        for task in lst:
          self.delete(task)
        self.wait()
      return self
1308455
def delete(self, endpoint: str, **kwargs) -> dict:
        """"""

        return self._request('DELETE', endpoint, **kwargs)
54857
def DeleteFlowRequests(self, requests):
    """"""
    for request in requests:
      if (request.client_id, request.flow_id) not in self.flows:
        raise db.UnknownFlowError(request.client_id, request.flow_id)

    for request in requests:
      key = (request.client_id, request.flow_id)
      request_dict = self.flow_requests.get(key, {})
      try:
        del request_dict[request.request_id]
      except KeyError:
        raise db.UnknownFlowRequestError(request.client_id, request.flow_id,
                                         request.request_id)

      response_dict = self.flow_responses.get(key, {})
      try:
        del response_dict[request.request_id]
      except KeyError:
        pass
877612
def client_delete(self, url, **kwargs):
        """"""
        response = requests.delete(self.make_url(url), headers=self.headers)
        if not response.ok:
            raise Exception(
                '{status}: {reason}.\nCircleCI Status NOT OK'.format(
                    status=response.status_code, reason=response.reason))
        return response.json()