HTTP DELETE
        - path: string  additionnal path to the uri
        - headers: dict, optionnal headers that will
            be added to HTTP request.
        - params: Optionnal parameterss added to the request
544925
def delete(self, path=None, headers=None):
        
        return self.request("DELETE", path=path, headers=headers)
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
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)
530250
def api_url path, params = {}
      url = File.join File.join(api_base_url, api_base_path), path
      "#{url}?#{api_query_string params}"
    end
532056
def delete(path, options = {}, &block)
      perform_request Net::HTTP::Delete, path, options, &block
    end
679784
def delete(path, body = nil, params = {}, headers = {})
      request_headers = request_headers(headers)
      request_options = {
          header: request_headers,
          body: encode_body(body, request_headers['Content-Type']),
          query: params
      }
      response = http_client.delete(request_uri(path), request_options)
      if response.status == 200
        parse_response(response)
      else
        handle_error_response(response)
      end
    end
407837
def delete(self, url):
        
        try:
            res = requests.delete(url, headers=self.headers)
            return json.loads(res.text)
        except Exception as e:
            print(e)
            return "error"
808789
def delete_by(params, request_options = {})
      raise ArgumentError.new('params cannot be nil, use the `clear` method to wipe the entire index') if params.nil?
      params = sanitized_delete_by_query_params(params)
      client.post(Protocol.delete_by_uri(name), params.to_json, :write, request_options)
    end
232630
def put(path, options = {}, headers = {}, raw = false)
      request(:put, path, options, headers, raw)
    end
349973
def delete(path: nil, payload: nil, headers: {}, query: {})
      execute(method: :delete, path: path, headers: headers, query: query, payload: payload)
    end
354854
def add_put(self, path: str, handler: _WebHandler,
                **kwargs: Any) -> AbstractRoute:
        
        return self.add_route(hdrs.METH_PUT, path, handler, **kwargs)
1033564
def rest_del(self, url, params=None, session=None, verify=True, cert=None):
        
        res = session.delete(url, params=params, verify=verify, cert=cert)
        return res.text, res.status_code
263461
def create_http_request(http_method, path, *arguments)
        http_method = http_method.to_sym

        if [:post, :put].include?(http_method)
          data = arguments.shift
        end

        headers = arguments.first.is_a?(Hash) ? arguments.shift : {}

        case http_method
        when :post
          request = Net::HTTP::Post.new(path,headers)
          request["Content-Length"] = 0 # Default to 0
        when :put
          request = Net::HTTP::Put.new(path,headers)
          request["Content-Length"] = 0 # Default to 0
        when :get
          request = Net::HTTP::Get.new(path,headers)
        when :delete
          request =  Net::HTTP::Delete.new(path,headers)
        else
          raise ArgumentError, "Don't know how to handle http_method: :#{http_method.to_s}"
        end
      
        # handling basic http auth
        request.basic_auth @config[:username], @config[:password]

        if data.is_a?(Hash)
          request.set_form_data(data)
        elsif data
          request.body = data.to_s
          request["Content-Length"] = request.body.length
        end

        request
      end
143410
def rest(path, params)
      endpoints = (params.delete(:only) || [:index, :show, :create, :update, :destroy]).to_a
      endpoints = endpoints - params.delete(:except).to_a
      endpoints.each do |endpoint|
        self.send(('restful_' + endpoint.to_s).to_sym, path, params)
      end
    end
817769
def post(path, params = {})
      headers = params.values.any? { |value| value.respond_to?(:to_io) } ? request_headers(:post, path, params, {}) : request_headers(:post, path, params)
      request(:post, path, params.to_json, headers)
    end
1037981
def delete(self, path, data={}):
        ''''''
        if len(data) != 0:
            parameter_string = ''
            for k,v in data.items():
                parameter_string += '{}={}'.format(k,v)
                parameter_string += '&'
            path += '?' + parameter_string

        response = requests.delete(API_URL + path, headers=self._set_headers())
        return self._check_response(response, self.delete, path, data)
392399
public Response delete(String path, Map<String, String> headers) throws IOException, RESTException {
        return parseResponse(getHttpResponse(new HttpDelete(baseUrl + path), headers));
    }