Get a DELETE HttpRequest object.
 @param [String] The URL to send the request to.
 @param [Hash, Optional] The headers for the HTTP Request.
962162
def delete(query_url,
               headers: {},
               parameters: {})
      HttpRequest.new(HttpMethodEnum::DELETE,
                      query_url,
                      headers: headers,
                      parameters: parameters)
    end
395824
def delete(self, action, headers=None):
        
        return self.request(make_url(self.endpoint, action), method='DELETE',
                            headers=headers)
513018
def get(path: nil, headers: {}, query: {})
      execute(method: :get, path: path, query: query, headers: headers)
    end
822816
def request(method, path, params, options)
      response = connection(options).run_request(method, nil, nil, nil) do |request|
        request.options[:raw] = true if options[:raw]
        case method.to_sym
        when :delete, :get
          request.url(path, params)
        when :post
          request.path = path
          request.body = params unless params.empty?
        end
      end
      options[:raw] ? response : response.body
    end
160965
def delete(http_connection)
      success = true
      tries ||= 3
      display = []
      display.push file_path
      if File.exists?(self.file_path)
        File.open(self.file_path) do |file|
          begin
            request = Net::HTTP::Delete.new(api_url_for_delete)
            WebTranslateIt::Util.add_fields(request)
            display.push Util.handle_response(http_connection.request(request))
            puts ArrayUtil.to_columns(display)
          rescue Timeout::Error
            puts StringUtil.failure("Request timeout. Will retry in 5 seconds.")
            if (tries -= 1) > 0
              sleep(5)
              retry
            else
              success = false
            end
          rescue
            display.push StringUtil.failure("An error occured: #{$!}")
            success = false
          end
        end
      else
        puts StringUtil.failure("\nFile #{self.file_path} doesn't exist!")
      end
      return success
    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"
318997
def rest_delete(url, timeout):
    ''''''
    try:
        response = requests.delete(url, timeout=timeout)
        return response
    except Exception as e:
        print('Get exception {0} when sending http delete to url {1}'.format(str(e), url))
        return None
433072
def _delete_request(self, url, headers, data=None):
        
        return self._session.delete(url, headers=headers, data=data)
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
1098846
def delete(url, params={}, options={})
      response = connection.delete do |req|
        req.saddle_options = options
        req.url(url, params)
      end
      handle_response(response)
    end
614183
def _delete(self, url):
        """"""
        r = requests.delete(self._api_prefix + url,
            headers=self.headers,
            auth=self.auth,
            allow_redirects=False,
        )
        return self._action(r)
731208
def delete(self, url, data=None, params=None):
        
        return self.request("delete", url, data, params)
601948
def delete_rsrc(rsrc, xml = nil)
      validate_connected
      raise MissingDataError, 'Missing :rsrc' if rsrc.nil?

      # payload?
      return delete_with_payload rsrc, xml if xml

      # delete the resource
      @last_http_response = @cnx[rsrc].delete
    rescue RestClient::ExceptionWithResponse => e
      handle_http_error e
    end
155592
public NextResponse delete(final String url, final Map<String, String> queries,
                               final Map<String, String> headers)
            throws IOException {
        return request(HttpMethod.DELETE, url, queries, null, headers);
    }
1099769
def _delete(self, *args, **kwargs):
        
        response = requests.delete(*args, **kwargs)
        response.raise_for_status()
409791
def delete(self, path, data=None, headers=None, params=None):
        
        self.request('DELETE', path=path, data=data, headers=headers, params=params)
121740
def request(opts = {})
      method = opts.delete(:_method)
      path = opts.delete(:_path)
      headers = opts.delete(:_headers)
      opts.delete_if { |key, _| key.to_s =~ /^_/ } # Remove all internal parameters
      if method == :options
        # Faraday doesn't support the OPTIONS verb because of a name collision with an internal options method
        # so we need to call run_request directly.
        request.headers.merge!(headers) if headers
        response = @connection.run_request method, path, opts, headers
      else
        response = @connection.send method do |request|
          request.headers.merge!(headers) if headers
          if method == :get
            # For GET requests, treat additional parameters as querystring data
            request.url path, opts
          else
            # For POST, PUT and DELETE requests, treat additional parameters as request body
            request.url path
            request.body = opts
          end
        end
      end
      { :parsed_data => response.env[:body], :response => response }
    end