Implements the Delete Detail (delete an object)

        maps to DELETE /api/object_name/:id/ in rest semantics
        :param request: rip.Request
        :return: rip.Response
496130
def delete_detail(self, request):
        
        pipeline = crud_pipeline_factory.delete_detail_pipeline(
            configuration=self.configuration)
        return pipeline(request=request)
1000790
def delete(self, request, *args, **kwargs):
        
        self.object = self.get_object()
        success_url = self.get_success_url()
        self.object.delete()

        if self.request.is_ajax():
            return JSONResponseMixin.render_to_response(self, context={})

        return HttpResponseRedirect(success_url)
983959
def _api_delete(self, api_key=None, **kwargs):
		
		api_key = api_key or self.default_api_key

		return self.api_retrieve(api_key=api_key).delete(**kwargs)
571710
def view_delete(self, id, **kwargs):
        ""
        api_path = "/api/v2/views/{id}.json"
        api_path = api_path.format(id=id)
        return self.call(api_path, method="DELETE", **kwargs)
962162
def delete(query_url,
               headers: {},
               parameters: {})
      HttpRequest.new(HttpMethodEnum::DELETE,
                      query_url,
                      headers: headers,
                      parameters: parameters)
    end
610885
def delete(path, options={}, raw=false, unformatted=true)
      request(:delete, path, options, raw, unformatted)
    end
777185
def delete_request(self, user_id, request_id):
        """"""
        return self.request(
            "{0}_{1}".format(request_id, user_id), method="DELETE"
        )
1033815
def __Delete(self, path, request, headers):
        
        return synchronized_request.SynchronizedRequest(self,
                                                        request,
                                                        self._global_endpoint_manager,
                                                        self.connection_policy,
                                                        self._requests_session,
                                                        'DELETE',
                                                        path,
                                                        request_data=None,
                                                        query_params=None,
                                                        headers=headers)
272761
def delete(path, options = {}, headers = {}, raw = false)
      request(:delete, path, options, headers, raw)
    end
480924
def delete(self, request, bot_id, id, format=None):
        
        return super(KikBotDetail, self).delete(request, bot_id, id, format)
296207
def delete(self, request, id):
        
        if self.readonly:
            return HTTPMethodNotAllowed(headers={'Allow': 'GET, HEAD'})
        session = self.Session()
        obj = session.query(self.mapped_class).get(id)
        if obj is None:
            return HTTPNotFound()
        if self.before_delete is not None:
            self.before_delete(request, obj)
        session.delete(obj)
        return Response(status_int=204)
731208
def delete(self, url, data=None, params=None):
        
        return self.request("delete", url, data, params)
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)
271272
def delete(self, endpoint, json=None, params=None, **kwargs):
        
        json = kwargs['data'] if 'data' in kwargs else json
        return self._make_request('delete', endpoint, data=json, params=params)
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
1301633
def _api_delete(path, data, server=None):
    '''
    
    '''
    server = _get_server(server)
    response = requests.delete(
            url=_get_url(server['ssl'], server['url'], server['port'], path),
            auth=_get_auth(server['user'], server['password']),
            headers=_get_headers(),
            params=data,
            verify=False
    )
    return _api_response(response)
1134580
def delete(self, raise_exc=True, headers=None, files=None):
        ''''''

        return self._request(DELETE, None, raise_exc, headers, files)