Creates an S3 DELETE request.
<p>
<code>create DELETE -&gt; request Object</code>
</p>

@param aBucket An S3 bucket
@param aKey An S3 key
@param aHandler An S3 handler
@return An S3 client request
334797
public S3ClientRequest createDeleteRequest(final String aBucket, final String aKey,
            final Handler<HttpClientResponse> aHandler) {
        final HttpClientRequest httpRequest = myHTTPClient.delete(PATH_SEP + aBucket + PATH_SEP + aKey, aHandler);
        return new S3ClientRequest("DELETE", aBucket, aKey, httpRequest, myAccessKey, mySecretKey, mySessionToken);
    }
677428
@SuppressWarnings("unused") // called through reflection by RequestServer
  public FramesV3 delete(int version, FramesV3 frames) {
    Frame frame = getFromDKV("key", frames.frame_id.key()); // safe
    frame.delete();             // lock & remove
    return frames;
  }
639725
public Request createGetRequest(String url, String apiKey, String accessToken) {
        HttpUrl.Builder httpBuilder = HttpUrl.parse(url).newBuilder();
        return new Request.Builder().url(httpBuilder.build()).header("User-Agent", USER_AGENT).header("X-Kite-Version", "3").header("Authorization", "token "+apiKey+":"+accessToken).build();
    }
434468
def remove_file_from_s3(awsclient, bucket, key):
    
    client_s3 = awsclient.get_client('s3')
    response = client_s3.delete_object(Bucket=bucket, Key=key)
1100633
public static RequestResponse callHttpDelete(HttpJsonRpcClient client, String url,
            Map<String, Object> headers, Map<String, Object> urlParams) {
        return client.doDelete(url, headers, urlParams);
    }
1186294
public HFCAAffiliation createDecendent(String name) throws InvalidArgumentException, AffiliationException {
        if (this.deleted) {
            throw new AffiliationException("Affiliation has been deleted");
        }
        validateAffiliationNames(name);
        return new HFCAAffiliation(this.name + "." + name, this.client);
    }
578248
protected Signer createSigner(final Request<?> request,
                                  final String bucketName,
                                  final String key,
                                  final boolean isAdditionalHeadRequestToFindRegion) {

        // Instead of using request.getEndpoint() for this parameter, we use endpoint which is because
        // in accelerate mode, the endpoint in request is regionless. We need the client-wide endpoint
        // to fetch the region information and pick the correct signer.
        URI uri = clientOptions.isAccelerateModeEnabled() ? endpoint : request.getEndpoint();
        final Signer signer = getSignerByURI(uri);

        if(this.awsCredentialsProvider.getCredentials() instanceof IBMOAuthCredentials) {
        	IBMOAuthCredentials oAuthCreds = (IBMOAuthCredentials)this.awsCredentialsProvider.getCredentials();
    		if (oAuthCreds.getApiKey() != null || oAuthCreds.getTokenManager() != null) {
            	return new IBMOAuthSigner(clientConfiguration);	
    		}
        }
        
        if (!isSignerOverridden()) {

            if ((signer instanceof AWSS3V4Signer) && bucketRegionShouldBeCached(request)) {

                String region = bucketRegionCache.get(bucketName);
                if (region != null) {
                     // If cache contains the region for the bucket, create an endpoint for the region and
                     // update the request with that endpoint.
                     resolveRequestEndpoint(request, bucketName, key, RuntimeHttpUtils.toUri(RegionUtils.getRegion(region).getServiceEndpoint(S3_SERVICE_NAME), clientConfiguration));
                     return updateSigV4SignerWithRegion((AWSS3V4Signer) signer, region);
                } else if (request.getOriginalRequest() instanceof GeneratePresignedUrlRequest) {
                    return createSigV2Signer(request, bucketName, key);
                } else if (isAdditionalHeadRequestToFindRegion) {
                    return updateSigV4SignerWithRegion((AWSS3V4Signer) signer, "us-east-1");
                }
            }

            String regionOverride = getSignerRegionOverride();
            if (regionOverride != null) {
                return updateSigV4SignerWithRegion(new AWSS3V4Signer(), regionOverride);
            }
        }
        if (signer instanceof S3Signer) {
            // The old S3Signer needs a method and path passed to its
            // constructor; if that's what we should use, getSigner()
            // will return a dummy instance and we need to create a
            // new one with the appropriate values for this request.
            return createSigV2Signer(request, bucketName, key);
        }

        return signer;
    }
637319
public function createHttpRequest(DeleteRequest $deleteRequest)
    {
        $request  = $this->createRequest('DELETE', $deleteRequest->type, $deleteRequest->bucket, $deleteRequest->key);
        $query    = $request->getQuery();

        $request->setHeader('Accept', ['multipart/mixed', '*/*']);

        if ($deleteRequest->vClock) {
            $request->setHeader('X-Riak-Vclock', $deleteRequest->vClock);
        }

        if ($deleteRequest->r !== null) {
            $query->add('r', $deleteRequest->r);
        }

        if ($deleteRequest->pr !== null) {
            $query->add('pr', $deleteRequest->pr);
        }

        if ($deleteRequest->rw !== null) {
            $query->add('rw', $deleteRequest->rw);
        }

        if ($deleteRequest->w !== null) {
            $query->add('w', $deleteRequest->w);
        }

        if ($deleteRequest->dw !== null) {
            $query->add('dw', $deleteRequest->dw);
        }

        if ($deleteRequest->pw !== null) {
            $query->add('pw', $deleteRequest->pw);
        }

        return $request;
    }
532858
@Nonnull
  public FineUploader5DeleteFile addParam (@Nonnull @Nonempty final String sKey, @Nonnull final String sValue)
  {
    ValueEnforcer.notEmpty (sKey, "Key");
    ValueEnforcer.notNull (sValue, "Value");

    m_aDeleteFileParams.put (sKey, sValue);
    return this;
  }
1143508
def delete(self, **params):
        
        self.clear()
        self._context = None
        self._set_value(self._default_value())
        self.bucket._client.delete(self, **params)
        return self
77616
public final HttpClient doAfterRequest(BiConsumer<? super HttpClientRequest, ? super Connection> doAfterRequest) {
		Objects.requireNonNull(doAfterRequest, "doAfterRequest");
		return new HttpClientDoOn(this, null, doAfterRequest, null, null);
	}
1039772
public T create(Map<String, Object> hash, MnoHttpClient httpClient) throws AuthenticationException, ApiException, InvalidRequestException {
		String jsonBody = httpClient.post(getCollectionUrl(), GSON.toJson(MnoMapHelper.toUnderscoreHash(hash)));

		Type parsingType = new MnoAccountResponseParameterizedType(entitityClass);
		MnoAccountResponse<T> resp = GSON.fromJson(jsonBody, parsingType);
		resp.validate();

		return resp.getData();
	}
1243945
private HttpExecutor createHttpExecutor(RequestMethodHolder requestMethodHolder) {
    HttpExecutor executor;
    if (customHttpClient == null) {
      executor = executorFactory.getHttpExecutor(requestMethodHolder.getBodyType());
    } else {
      executor = executorFactory.getHttpExecutor(requestMethodHolder.getBodyType(), customHttpClient);
    }
    executor.setCharset(charset);
    executor.setProxy(this.proxy);
    executor.setTimeout(timeout.socketTimeout, timeout.connectTimeout);
    return executor;
  }
216606
@Override
    public java.util.concurrent.Future<DeleteMessageResult> deleteMessageAsync(String queueUrl, String receiptHandle) {

        return deleteMessageAsync(new DeleteMessageRequest().withQueueUrl(queueUrl).withReceiptHandle(receiptHandle));
    }
1270596
public static IndexingResult delete(EsClient client, IndexType indexType, SearchRequestBuilder searchRequest) {
    BulkIndexer bulk = new BulkIndexer(client, indexType, Size.REGULAR);
    bulk.start();
    bulk.addDeletion(searchRequest);
    return bulk.stop();
  }
1016835
def delete_api_key(awsclient, api_key):
    
    _sleep()
    client_api = awsclient.get_client('apigateway')
    print('delete api key: %s' % api_key)

    response = client_api.delete_api_key(
        apiKey=api_key
    )

    print(json2table(response))
424534
public static DeleteRequest checkRequest(final HttpServletRequest request,
			final DeleteResponse deleteResponse) {
		final DeleteRequestType type = checkType(request, deleteResponse);
		if (type != null) {
			return new DeleteRequest(type);
		}

		return null;
	}