com.amazonaws.services.forecast.AmazonForecastClient Maven / Gradle / Ivy
Show all versions of aws-java-sdk-forecast Show documentation
/*
* Copyright 2019-2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
* the License. A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
* and limitations under the License.
*/
package com.amazonaws.services.forecast;
import org.w3c.dom.*;
import java.net.*;
import java.util.*;
import javax.annotation.Generated;
import org.apache.commons.logging.*;
import com.amazonaws.*;
import com.amazonaws.annotation.SdkInternalApi;
import com.amazonaws.auth.*;
import com.amazonaws.handlers.*;
import com.amazonaws.http.*;
import com.amazonaws.internal.*;
import com.amazonaws.internal.auth.*;
import com.amazonaws.metrics.*;
import com.amazonaws.regions.*;
import com.amazonaws.transform.*;
import com.amazonaws.util.*;
import com.amazonaws.protocol.json.*;
import com.amazonaws.util.AWSRequestMetrics.Field;
import com.amazonaws.annotation.ThreadSafe;
import com.amazonaws.client.AwsSyncClientParams;
import com.amazonaws.client.builder.AdvancedConfig;
import com.amazonaws.services.forecast.AmazonForecastClientBuilder;
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.forecast.model.*;
import com.amazonaws.services.forecast.model.transform.*;
/**
* Client for accessing Amazon Forecast Service. All service calls made using this client are blocking, and will not
* return until the service call completes.
*
*
* Provides APIs for creating and managing Amazon Forecast resources.
*
*/
@ThreadSafe
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class AmazonForecastClient extends AmazonWebServiceClient implements AmazonForecast {
/** Provider for AWS credentials. */
private final AWSCredentialsProvider awsCredentialsProvider;
private static final Log log = LogFactory.getLog(AmazonForecast.class);
/** Default signing name for the service. */
private static final String DEFAULT_SIGNING_NAME = "forecast";
/** Client configuration factory providing ClientConfigurations tailored to this client */
protected static final ClientConfigurationFactory configFactory = new ClientConfigurationFactory();
private final AdvancedConfig advancedConfig;
private static final com.amazonaws.protocol.json.SdkJsonProtocolFactory protocolFactory = new com.amazonaws.protocol.json.SdkJsonProtocolFactory(
new JsonClientMetadata()
.withProtocolVersion("1.1")
.withSupportsCbor(false)
.withSupportsIon(false)
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("InvalidNextTokenException").withExceptionUnmarshaller(
com.amazonaws.services.forecast.model.transform.InvalidNextTokenExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("LimitExceededException").withExceptionUnmarshaller(
com.amazonaws.services.forecast.model.transform.LimitExceededExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ResourceNotFoundException").withExceptionUnmarshaller(
com.amazonaws.services.forecast.model.transform.ResourceNotFoundExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ResourceAlreadyExistsException").withExceptionUnmarshaller(
com.amazonaws.services.forecast.model.transform.ResourceAlreadyExistsExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ResourceInUseException").withExceptionUnmarshaller(
com.amazonaws.services.forecast.model.transform.ResourceInUseExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("InvalidInputException").withExceptionUnmarshaller(
com.amazonaws.services.forecast.model.transform.InvalidInputExceptionUnmarshaller.getInstance()))
.withBaseServiceExceptionClass(com.amazonaws.services.forecast.model.AmazonForecastException.class));
public static AmazonForecastClientBuilder builder() {
return AmazonForecastClientBuilder.standard();
}
/**
* Constructs a new client to invoke service methods on Amazon Forecast Service using the specified parameters.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param clientParams
* Object providing client parameters.
*/
AmazonForecastClient(AwsSyncClientParams clientParams) {
this(clientParams, false);
}
/**
* Constructs a new client to invoke service methods on Amazon Forecast Service using the specified parameters.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param clientParams
* Object providing client parameters.
*/
AmazonForecastClient(AwsSyncClientParams clientParams, boolean endpointDiscoveryEnabled) {
super(clientParams);
this.awsCredentialsProvider = clientParams.getCredentialsProvider();
this.advancedConfig = clientParams.getAdvancedConfig();
init();
}
private void init() {
setServiceNameIntern(DEFAULT_SIGNING_NAME);
setEndpointPrefix(ENDPOINT_PREFIX);
// calling this.setEndPoint(...) will also modify the signer accordingly
setEndpoint("forecast.us-east-1.amazonaws.com");
HandlerChainFactory chainFactory = new HandlerChainFactory();
requestHandler2s.addAll(chainFactory.newRequestHandlerChain("/com/amazonaws/services/forecast/request.handlers"));
requestHandler2s.addAll(chainFactory.newRequestHandler2Chain("/com/amazonaws/services/forecast/request.handler2s"));
requestHandler2s.addAll(chainFactory.getGlobalHandlers());
}
/**
*
* Creates an Amazon Forecast predictor.
*
*
* Amazon Forecast creates predictors with AutoPredictor, which involves applying the optimal combination of
* algorithms to each time series in your datasets. You can use CreateAutoPredictor to create new predictors
* or upgrade/retrain existing predictors.
*
*
* Creating new predictors
*
*
* The following parameters are required when creating a new predictor:
*
*
* -
*
* PredictorName - A unique name for the predictor.
*
*
* -
*
* DatasetGroupArn - The ARN of the dataset group used to train the predictor.
*
*
* -
*
* ForecastFrequency - The granularity of your forecasts (hourly, daily, weekly, etc).
*
*
* -
*
* ForecastHorizon - The number of time-steps that the model predicts. The forecast horizon is also
* called the prediction length.
*
*
*
*
* When creating a new predictor, do not specify a value for ReferencePredictorArn.
*
*
* Upgrading and retraining predictors
*
*
* The following parameters are required when retraining or upgrading a predictor:
*
*
* -
*
* PredictorName - A unique name for the predictor.
*
*
* -
*
* ReferencePredictorArn - The ARN of the predictor to retrain or upgrade.
*
*
*
*
* When upgrading or retraining a predictor, only specify values for the ReferencePredictorArn and
* PredictorName.
*
*
* @param createAutoPredictorRequest
* @return Result of the CreateAutoPredictor operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceAlreadyExistsException
* There is already a resource with this name. Try again with a different name.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @throws ResourceInUseException
* The specified resource is in use.
* @throws LimitExceededException
* The limit on the number of resources per account has been exceeded.
* @sample AmazonForecast.CreateAutoPredictor
* @see AWS
* API Documentation
*/
@Override
public CreateAutoPredictorResult createAutoPredictor(CreateAutoPredictorRequest request) {
request = beforeClientExecution(request);
return executeCreateAutoPredictor(request);
}
@SdkInternalApi
final CreateAutoPredictorResult executeCreateAutoPredictor(CreateAutoPredictorRequest createAutoPredictorRequest) {
ExecutionContext executionContext = createExecutionContext(createAutoPredictorRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateAutoPredictorRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createAutoPredictorRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateAutoPredictor");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateAutoPredictorResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates an Amazon Forecast dataset. The information about the dataset that you provide helps Forecast understand
* how to consume the data for model training. This includes the following:
*
*
* -
*
* DataFrequency - How frequently your historical time-series data is collected.
*
*
* -
*
* Domain and DatasetType - Each dataset has an associated dataset
* domain and a type within the domain. Amazon Forecast provides a list of predefined domains and types within each
* domain. For each unique dataset domain and type within the domain, Amazon Forecast requires your data to include
* a minimum set of predefined fields.
*
*
* -
*
* Schema - A schema specifies the fields in the dataset, including the field name and data
* type.
*
*
*
*
* After creating a dataset, you import your training data into it and add the dataset to a dataset group. You use
* the dataset group to create a predictor. For more information, see Importing datasets.
*
*
* To get a list of all your datasets, use the ListDatasets operation.
*
*
* For example Forecast datasets, see the Amazon
* Forecast Sample GitHub repository.
*
*
*
* The Status of a dataset must be ACTIVE before you can import training data. Use the DescribeDataset operation to
* get the status.
*
*
*
* @param createDatasetRequest
* @return Result of the CreateDataset operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceAlreadyExistsException
* There is already a resource with this name. Try again with a different name.
* @throws LimitExceededException
* The limit on the number of resources per account has been exceeded.
* @sample AmazonForecast.CreateDataset
* @see AWS API
* Documentation
*/
@Override
public CreateDatasetResult createDataset(CreateDatasetRequest request) {
request = beforeClientExecution(request);
return executeCreateDataset(request);
}
@SdkInternalApi
final CreateDatasetResult executeCreateDataset(CreateDatasetRequest createDatasetRequest) {
ExecutionContext executionContext = createExecutionContext(createDatasetRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateDatasetRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createDatasetRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateDataset");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateDatasetResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a dataset group, which holds a collection of related datasets. You can add datasets to the dataset group
* when you create the dataset group, or later by using the UpdateDatasetGroup
* operation.
*
*
* After creating a dataset group and adding datasets, you use the dataset group when you create a predictor. For
* more information, see Dataset groups.
*
*
* To get a list of all your datasets groups, use the ListDatasetGroups operation.
*
*
*
* The Status of a dataset group must be ACTIVE before you can use the dataset group to
* create a predictor. To get the status, use the DescribeDatasetGroup
* operation.
*
*
*
* @param createDatasetGroupRequest
* @return Result of the CreateDatasetGroup operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceAlreadyExistsException
* There is already a resource with this name. Try again with a different name.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @throws ResourceInUseException
* The specified resource is in use.
* @throws LimitExceededException
* The limit on the number of resources per account has been exceeded.
* @sample AmazonForecast.CreateDatasetGroup
* @see AWS
* API Documentation
*/
@Override
public CreateDatasetGroupResult createDatasetGroup(CreateDatasetGroupRequest request) {
request = beforeClientExecution(request);
return executeCreateDatasetGroup(request);
}
@SdkInternalApi
final CreateDatasetGroupResult executeCreateDatasetGroup(CreateDatasetGroupRequest createDatasetGroupRequest) {
ExecutionContext executionContext = createExecutionContext(createDatasetGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateDatasetGroupRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createDatasetGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateDatasetGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateDatasetGroupResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Imports your training data to an Amazon Forecast dataset. You provide the location of your training data in an
* Amazon Simple Storage Service (Amazon S3) bucket and the Amazon Resource Name (ARN) of the dataset that you want
* to import the data to.
*
*
* You must specify a DataSource
* object that includes an Identity and Access Management (IAM) role that Amazon Forecast can assume to access the
* data, as Amazon Forecast makes a copy of your data and processes it in an internal Amazon Web Services system.
* For more information, see Set up permissions.
*
*
* The training data must be in CSV or Parquet format. The delimiter must be a comma (,).
*
*
* You can specify the path to a specific file, the S3 bucket, or to a folder in the S3 bucket. For the latter two
* cases, Amazon Forecast imports all files up to the limit of 10,000 files.
*
*
* Because dataset imports are not aggregated, your most recent dataset import is the one that is used when training
* a predictor or generating a forecast. Make sure that your most recent dataset import contains all of the data you
* want to model off of, and not just the new data collected since the previous import.
*
*
* To get a list of all your dataset import jobs, filtered by specified criteria, use the ListDatasetImportJobs
* operation.
*
*
* @param createDatasetImportJobRequest
* @return Result of the CreateDatasetImportJob operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceAlreadyExistsException
* There is already a resource with this name. Try again with a different name.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @throws ResourceInUseException
* The specified resource is in use.
* @throws LimitExceededException
* The limit on the number of resources per account has been exceeded.
* @sample AmazonForecast.CreateDatasetImportJob
* @see AWS API Documentation
*/
@Override
public CreateDatasetImportJobResult createDatasetImportJob(CreateDatasetImportJobRequest request) {
request = beforeClientExecution(request);
return executeCreateDatasetImportJob(request);
}
@SdkInternalApi
final CreateDatasetImportJobResult executeCreateDatasetImportJob(CreateDatasetImportJobRequest createDatasetImportJobRequest) {
ExecutionContext executionContext = createExecutionContext(createDatasetImportJobRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateDatasetImportJobRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createDatasetImportJobRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateDatasetImportJob");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CreateDatasetImportJobResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
*
* Explainability is only available for Forecasts and Predictors generated from an AutoPredictor
* (CreateAutoPredictor)
*
*
*
* Creates an Amazon Forecast Explainability.
*
*
* Explainability helps you better understand how the attributes in your datasets impact forecast. Amazon Forecast
* uses a metric called Impact scores to quantify the relative impact of each attribute and determine whether they
* increase or decrease forecast values.
*
*
* To enable Forecast Explainability, your predictor must include at least one of the following: related time
* series, item metadata, or additional datasets like Holidays and the Weather Index.
*
*
* CreateExplainability accepts either a Predictor ARN or Forecast ARN. To receive aggregated Impact scores for all
* time series and time points in your datasets, provide a Predictor ARN. To receive Impact scores for specific time
* series and time points, provide a Forecast ARN.
*
*
* CreateExplainability with a Predictor ARN
*
*
*
* You can only have one Explainability resource per predictor. If you already enabled ExplainPredictor
* in CreateAutoPredictor, that predictor already has an Explainability resource.
*
*
*
* The following parameters are required when providing a Predictor ARN:
*
*
* -
*
* ExplainabilityName - A unique name for the Explainability.
*
*
* -
*
* ResourceArn - The Arn of the predictor.
*
*
* -
*
* TimePointGranularity - Must be set to “ALL”.
*
*
* -
*
* TimeSeriesGranularity - Must be set to “ALL”.
*
*
*
*
* Do not specify a value for the following parameters:
*
*
* -
*
* DataSource - Only valid when TimeSeriesGranularity is “SPECIFIC”.
*
*
* -
*
* Schema - Only valid when TimeSeriesGranularity is “SPECIFIC”.
*
*
* -
*
* StartDateTime - Only valid when TimePointGranularity is “SPECIFIC”.
*
*
* -
*
* EndDateTime - Only valid when TimePointGranularity is “SPECIFIC”.
*
*
*
*
* CreateExplainability with a Forecast ARN
*
*
*
* You can specify a maximum of 50 time series and 500 time points.
*
*
*
* The following parameters are required when providing a Predictor ARN:
*
*
* -
*
* ExplainabilityName - A unique name for the Explainability.
*
*
* -
*
* ResourceArn - The Arn of the forecast.
*
*
* -
*
* TimePointGranularity - Either “ALL” or “SPECIFIC”.
*
*
* -
*
* TimeSeriesGranularity - Either “ALL” or “SPECIFIC”.
*
*
*
*
* If you set TimeSeriesGranularity to “SPECIFIC”, you must also provide the following:
*
*
* -
*
* DataSource - The S3 location of the CSV file specifying your time series.
*
*
* -
*
* Schema - The Schema defines the attributes and attribute types listed in the Data Source.
*
*
*
*
* If you set TimePointGranularity to “SPECIFIC”, you must also provide the following:
*
*
* -
*
* StartDateTime - The first timestamp in the range of time points.
*
*
* -
*
* EndDateTime - The last timestamp in the range of time points.
*
*
*
*
* @param createExplainabilityRequest
* @return Result of the CreateExplainability operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceAlreadyExistsException
* There is already a resource with this name. Try again with a different name.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @throws ResourceInUseException
* The specified resource is in use.
* @throws LimitExceededException
* The limit on the number of resources per account has been exceeded.
* @sample AmazonForecast.CreateExplainability
* @see AWS
* API Documentation
*/
@Override
public CreateExplainabilityResult createExplainability(CreateExplainabilityRequest request) {
request = beforeClientExecution(request);
return executeCreateExplainability(request);
}
@SdkInternalApi
final CreateExplainabilityResult executeCreateExplainability(CreateExplainabilityRequest createExplainabilityRequest) {
ExecutionContext executionContext = createExecutionContext(createExplainabilityRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateExplainabilityRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createExplainabilityRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateExplainability");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateExplainabilityResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Exports an Explainability resource created by the CreateExplainability operation. Exported files are
* exported to an Amazon Simple Storage Service (Amazon S3) bucket.
*
*
* You must specify a DataDestination object that includes an Amazon S3 bucket and an Identity and Access
* Management (IAM) role that Amazon Forecast can assume to access the Amazon S3 bucket. For more information, see
* aws-forecast-iam-roles.
*
*
*
* The Status of the export job must be ACTIVE before you can access the export in your
* Amazon S3 bucket. To get the status, use the DescribeExplainabilityExport operation.
*
*
*
* @param createExplainabilityExportRequest
* @return Result of the CreateExplainabilityExport operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceAlreadyExistsException
* There is already a resource with this name. Try again with a different name.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @throws ResourceInUseException
* The specified resource is in use.
* @throws LimitExceededException
* The limit on the number of resources per account has been exceeded.
* @sample AmazonForecast.CreateExplainabilityExport
* @see AWS API Documentation
*/
@Override
public CreateExplainabilityExportResult createExplainabilityExport(CreateExplainabilityExportRequest request) {
request = beforeClientExecution(request);
return executeCreateExplainabilityExport(request);
}
@SdkInternalApi
final CreateExplainabilityExportResult executeCreateExplainabilityExport(CreateExplainabilityExportRequest createExplainabilityExportRequest) {
ExecutionContext executionContext = createExecutionContext(createExplainabilityExportRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateExplainabilityExportRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(createExplainabilityExportRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateExplainabilityExport");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CreateExplainabilityExportResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a forecast for each item in the TARGET_TIME_SERIES dataset that was used to train the
* predictor. This is known as inference. To retrieve the forecast for a single item at low latency, use the
* operation. To export the complete forecast into your Amazon Simple Storage Service (Amazon S3) bucket, use the
* CreateForecastExportJob operation.
*
*
* The range of the forecast is determined by the ForecastHorizon value, which you specify in the
* CreatePredictor request. When you query a forecast, you can request a specific date range within the
* forecast.
*
*
* To get a list of all your forecasts, use the ListForecasts operation.
*
*
*
* The forecasts generated by Amazon Forecast are in the same time zone as the dataset that was used to create the
* predictor.
*
*
*
* For more information, see howitworks-forecast.
*
*
*
* The Status of the forecast must be ACTIVE before you can query or export the forecast.
* Use the DescribeForecast operation to get the status.
*
*
*
* By default, a forecast includes predictions for every item (item_id) in the dataset group that was
* used to train the predictor. However, you can use the TimeSeriesSelector object to generate a
* forecast on a subset of time series. Forecast creation is skipped for any time series that you specify that are
* not in the input dataset. The forecast export file will not contain these time series or their forecasted values.
*
*
* @param createForecastRequest
* @return Result of the CreateForecast operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceAlreadyExistsException
* There is already a resource with this name. Try again with a different name.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @throws ResourceInUseException
* The specified resource is in use.
* @throws LimitExceededException
* The limit on the number of resources per account has been exceeded.
* @sample AmazonForecast.CreateForecast
* @see AWS API
* Documentation
*/
@Override
public CreateForecastResult createForecast(CreateForecastRequest request) {
request = beforeClientExecution(request);
return executeCreateForecast(request);
}
@SdkInternalApi
final CreateForecastResult executeCreateForecast(CreateForecastRequest createForecastRequest) {
ExecutionContext executionContext = createExecutionContext(createForecastRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateForecastRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createForecastRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateForecast");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateForecastResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Exports a forecast created by the CreateForecast operation to your Amazon Simple Storage Service (Amazon
* S3) bucket. The forecast file name will match the following conventions:
*
*
* <ForecastExportJobName>_<ExportTimestamp>_<PartNumber>
*
*
* where the <ExportTimestamp> component is in Java SimpleDateFormat (yyyy-MM-ddTHH-mm-ssZ).
*
*
* You must specify a DataDestination object that includes an Identity and Access Management (IAM) role that
* Amazon Forecast can assume to access the Amazon S3 bucket. For more information, see
* aws-forecast-iam-roles.
*
*
* For more information, see howitworks-forecast.
*
*
* To get a list of all your forecast export jobs, use the ListForecastExportJobs operation.
*
*
*
* The Status of the forecast export job must be ACTIVE before you can access the forecast
* in your Amazon S3 bucket. To get the status, use the DescribeForecastExportJob operation.
*
*
*
* @param createForecastExportJobRequest
* @return Result of the CreateForecastExportJob operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceAlreadyExistsException
* There is already a resource with this name. Try again with a different name.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @throws ResourceInUseException
* The specified resource is in use.
* @throws LimitExceededException
* The limit on the number of resources per account has been exceeded.
* @sample AmazonForecast.CreateForecastExportJob
* @see AWS API Documentation
*/
@Override
public CreateForecastExportJobResult createForecastExportJob(CreateForecastExportJobRequest request) {
request = beforeClientExecution(request);
return executeCreateForecastExportJob(request);
}
@SdkInternalApi
final CreateForecastExportJobResult executeCreateForecastExportJob(CreateForecastExportJobRequest createForecastExportJobRequest) {
ExecutionContext executionContext = createExecutionContext(createForecastExportJobRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateForecastExportJobRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(createForecastExportJobRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateForecastExportJob");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CreateForecastExportJobResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a predictor monitor resource for an existing auto predictor. Predictor monitoring allows you to see how
* your predictor's performance changes over time. For more information, see Predictor Monitoring.
*
*
* @param createMonitorRequest
* @return Result of the CreateMonitor operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceAlreadyExistsException
* There is already a resource with this name. Try again with a different name.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @throws ResourceInUseException
* The specified resource is in use.
* @throws LimitExceededException
* The limit on the number of resources per account has been exceeded.
* @sample AmazonForecast.CreateMonitor
* @see AWS API
* Documentation
*/
@Override
public CreateMonitorResult createMonitor(CreateMonitorRequest request) {
request = beforeClientExecution(request);
return executeCreateMonitor(request);
}
@SdkInternalApi
final CreateMonitorResult executeCreateMonitor(CreateMonitorRequest createMonitorRequest) {
ExecutionContext executionContext = createExecutionContext(createMonitorRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateMonitorRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createMonitorRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateMonitor");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateMonitorResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
*
* This operation creates a legacy predictor that does not include all the predictor functionalities provided by
* Amazon Forecast. To create a predictor that is compatible with all aspects of Forecast, use
* CreateAutoPredictor.
*
*
*
* Creates an Amazon Forecast predictor.
*
*
* In the request, provide a dataset group and either specify an algorithm or let Amazon Forecast choose an
* algorithm for you using AutoML. If you specify an algorithm, you also can override algorithm-specific
* hyperparameters.
*
*
* Amazon Forecast uses the algorithm to train a predictor using the latest version of the datasets in the specified
* dataset group. You can then generate a forecast using the CreateForecast operation.
*
*
* To see the evaluation metrics, use the GetAccuracyMetrics operation.
*
*
* You can specify a featurization configuration to fill and aggregate the data fields in the
* TARGET_TIME_SERIES dataset to improve model training. For more information, see
* FeaturizationConfig.
*
*
* For RELATED_TIME_SERIES datasets, CreatePredictor verifies that the DataFrequency
* specified when the dataset was created matches the ForecastFrequency. TARGET_TIME_SERIES datasets
* don't have this restriction. Amazon Forecast also verifies the delimiter and timestamp format. For more
* information, see howitworks-datasets-groups.
*
*
* By default, predictors are trained and evaluated at the 0.1 (P10), 0.5 (P50), and 0.9 (P90) quantiles. You can
* choose custom forecast types to train and evaluate your predictor by setting the ForecastTypes.
*
*
* AutoML
*
*
* If you want Amazon Forecast to evaluate each algorithm and choose the one that minimizes the
* objective function, set PerformAutoML to true. The
* objective function is defined as the mean of the weighted losses over the forecast types. By
* default, these are the p10, p50, and p90 quantile losses. For more information, see EvaluationResult.
*
*
* When AutoML is enabled, the following properties are disallowed:
*
*
* -
*
* AlgorithmArn
*
*
* -
*
* HPOConfig
*
*
* -
*
* PerformHPO
*
*
* -
*
* TrainingParameters
*
*
*
*
* To get a list of all of your predictors, use the ListPredictors operation.
*
*
*
* Before you can use the predictor to create a forecast, the Status of the predictor must be
* ACTIVE, signifying that training has completed. To get the status, use the DescribePredictor
* operation.
*
*
*
* @param createPredictorRequest
* @return Result of the CreatePredictor operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceAlreadyExistsException
* There is already a resource with this name. Try again with a different name.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @throws ResourceInUseException
* The specified resource is in use.
* @throws LimitExceededException
* The limit on the number of resources per account has been exceeded.
* @sample AmazonForecast.CreatePredictor
* @see AWS API
* Documentation
*/
@Override
public CreatePredictorResult createPredictor(CreatePredictorRequest request) {
request = beforeClientExecution(request);
return executeCreatePredictor(request);
}
@SdkInternalApi
final CreatePredictorResult executeCreatePredictor(CreatePredictorRequest createPredictorRequest) {
ExecutionContext executionContext = createExecutionContext(createPredictorRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreatePredictorRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createPredictorRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreatePredictor");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreatePredictorResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Exports backtest forecasts and accuracy metrics generated by the CreateAutoPredictor or
* CreatePredictor operations. Two folders containing CSV or Parquet files are exported to your specified S3
* bucket.
*
*
* The export file names will match the following conventions:
*
*
* <ExportJobName>_<ExportTimestamp>_<PartNumber>.csv
*
*
* The <ExportTimestamp> component is in Java SimpleDate format (yyyy-MM-ddTHH-mm-ssZ).
*
*
* You must specify a DataDestination object that includes an Amazon S3 bucket and an Identity and Access
* Management (IAM) role that Amazon Forecast can assume to access the Amazon S3 bucket. For more information, see
* aws-forecast-iam-roles.
*
*
*
* The Status of the export job must be ACTIVE before you can access the export in your
* Amazon S3 bucket. To get the status, use the DescribePredictorBacktestExportJob operation.
*
*
*
* @param createPredictorBacktestExportJobRequest
* @return Result of the CreatePredictorBacktestExportJob operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceAlreadyExistsException
* There is already a resource with this name. Try again with a different name.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @throws ResourceInUseException
* The specified resource is in use.
* @throws LimitExceededException
* The limit on the number of resources per account has been exceeded.
* @sample AmazonForecast.CreatePredictorBacktestExportJob
* @see AWS API Documentation
*/
@Override
public CreatePredictorBacktestExportJobResult createPredictorBacktestExportJob(CreatePredictorBacktestExportJobRequest request) {
request = beforeClientExecution(request);
return executeCreatePredictorBacktestExportJob(request);
}
@SdkInternalApi
final CreatePredictorBacktestExportJobResult executeCreatePredictorBacktestExportJob(
CreatePredictorBacktestExportJobRequest createPredictorBacktestExportJobRequest) {
ExecutionContext executionContext = createExecutionContext(createPredictorBacktestExportJobRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreatePredictorBacktestExportJobRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(createPredictorBacktestExportJobRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreatePredictorBacktestExportJob");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CreatePredictorBacktestExportJobResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* What-if analysis is a scenario modeling technique where you make a hypothetical change to a time series and
* compare the forecasts generated by these changes against the baseline, unchanged time series. It is important to
* remember that the purpose of a what-if analysis is to understand how a forecast can change given different
* modifications to the baseline time series.
*
*
* For example, imagine you are a clothing retailer who is considering an end of season sale to clear space for new
* styles. After creating a baseline forecast, you can use a what-if analysis to investigate how different sales
* tactics might affect your goals.
*
*
* You could create a scenario where everything is given a 25% markdown, and another where everything is given a
* fixed dollar markdown. You could create a scenario where the sale lasts for one week and another where the sale
* lasts for one month. With a what-if analysis, you can compare many different scenarios against each other.
*
*
* Note that a what-if analysis is meant to display what the forecasting model has learned and how it will behave in
* the scenarios that you are evaluating. Do not blindly use the results of the what-if analysis to make business
* decisions. For instance, forecasts might not be accurate for novel scenarios where there is no reference
* available to determine whether a forecast is good.
*
*
* The TimeSeriesSelector object defines the items that you want in the what-if analysis.
*
*
* @param createWhatIfAnalysisRequest
* @return Result of the CreateWhatIfAnalysis operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceAlreadyExistsException
* There is already a resource with this name. Try again with a different name.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @throws ResourceInUseException
* The specified resource is in use.
* @throws LimitExceededException
* The limit on the number of resources per account has been exceeded.
* @sample AmazonForecast.CreateWhatIfAnalysis
* @see AWS
* API Documentation
*/
@Override
public CreateWhatIfAnalysisResult createWhatIfAnalysis(CreateWhatIfAnalysisRequest request) {
request = beforeClientExecution(request);
return executeCreateWhatIfAnalysis(request);
}
@SdkInternalApi
final CreateWhatIfAnalysisResult executeCreateWhatIfAnalysis(CreateWhatIfAnalysisRequest createWhatIfAnalysisRequest) {
ExecutionContext executionContext = createExecutionContext(createWhatIfAnalysisRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateWhatIfAnalysisRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createWhatIfAnalysisRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateWhatIfAnalysis");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateWhatIfAnalysisResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* A what-if forecast is a forecast that is created from a modified version of the baseline forecast. Each what-if
* forecast incorporates either a replacement dataset or a set of transformations to the original dataset.
*
*
* @param createWhatIfForecastRequest
* @return Result of the CreateWhatIfForecast operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceAlreadyExistsException
* There is already a resource with this name. Try again with a different name.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @throws ResourceInUseException
* The specified resource is in use.
* @throws LimitExceededException
* The limit on the number of resources per account has been exceeded.
* @sample AmazonForecast.CreateWhatIfForecast
* @see AWS
* API Documentation
*/
@Override
public CreateWhatIfForecastResult createWhatIfForecast(CreateWhatIfForecastRequest request) {
request = beforeClientExecution(request);
return executeCreateWhatIfForecast(request);
}
@SdkInternalApi
final CreateWhatIfForecastResult executeCreateWhatIfForecast(CreateWhatIfForecastRequest createWhatIfForecastRequest) {
ExecutionContext executionContext = createExecutionContext(createWhatIfForecastRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateWhatIfForecastRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createWhatIfForecastRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateWhatIfForecast");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateWhatIfForecastResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Exports a forecast created by the CreateWhatIfForecast operation to your Amazon Simple Storage Service
* (Amazon S3) bucket. The forecast file name will match the following conventions:
*
*
* ≈<ForecastExportJobName>_<ExportTimestamp>_<PartNumber>
*
*
* The <ExportTimestamp> component is in Java SimpleDateFormat (yyyy-MM-ddTHH-mm-ssZ).
*
*
* You must specify a DataDestination object that includes an Identity and Access Management (IAM) role that
* Amazon Forecast can assume to access the Amazon S3 bucket. For more information, see
* aws-forecast-iam-roles.
*
*
* For more information, see howitworks-forecast.
*
*
* To get a list of all your what-if forecast export jobs, use the ListWhatIfForecastExports operation.
*
*
*
* The Status of the forecast export job must be ACTIVE before you can access the forecast
* in your Amazon S3 bucket. To get the status, use the DescribeWhatIfForecastExport operation.
*
*
*
* @param createWhatIfForecastExportRequest
* @return Result of the CreateWhatIfForecastExport operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceAlreadyExistsException
* There is already a resource with this name. Try again with a different name.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @throws ResourceInUseException
* The specified resource is in use.
* @throws LimitExceededException
* The limit on the number of resources per account has been exceeded.
* @sample AmazonForecast.CreateWhatIfForecastExport
* @see AWS API Documentation
*/
@Override
public CreateWhatIfForecastExportResult createWhatIfForecastExport(CreateWhatIfForecastExportRequest request) {
request = beforeClientExecution(request);
return executeCreateWhatIfForecastExport(request);
}
@SdkInternalApi
final CreateWhatIfForecastExportResult executeCreateWhatIfForecastExport(CreateWhatIfForecastExportRequest createWhatIfForecastExportRequest) {
ExecutionContext executionContext = createExecutionContext(createWhatIfForecastExportRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateWhatIfForecastExportRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(createWhatIfForecastExportRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateWhatIfForecastExport");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CreateWhatIfForecastExportResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes an Amazon Forecast dataset that was created using the CreateDataset operation. You can
* only delete datasets that have a status of ACTIVE or CREATE_FAILED. To get the status
* use the DescribeDataset
* operation.
*
*
*
* Forecast does not automatically update any dataset groups that contain the deleted dataset. In order to update
* the dataset group, use the UpdateDatasetGroup
* operation, omitting the deleted dataset's ARN.
*
*
*
* @param deleteDatasetRequest
* @return Result of the DeleteDataset operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @throws ResourceInUseException
* The specified resource is in use.
* @sample AmazonForecast.DeleteDataset
* @see AWS API
* Documentation
*/
@Override
public DeleteDatasetResult deleteDataset(DeleteDatasetRequest request) {
request = beforeClientExecution(request);
return executeDeleteDataset(request);
}
@SdkInternalApi
final DeleteDatasetResult executeDeleteDataset(DeleteDatasetRequest deleteDatasetRequest) {
ExecutionContext executionContext = createExecutionContext(deleteDatasetRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteDatasetRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteDatasetRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteDataset");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteDatasetResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a dataset group created using the CreateDatasetGroup
* operation. You can only delete dataset groups that have a status of ACTIVE,
* CREATE_FAILED, or UPDATE_FAILED. To get the status, use the DescribeDatasetGroup
* operation.
*
*
* This operation deletes only the dataset group, not the datasets in the group.
*
*
* @param deleteDatasetGroupRequest
* @return Result of the DeleteDatasetGroup operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @throws ResourceInUseException
* The specified resource is in use.
* @sample AmazonForecast.DeleteDatasetGroup
* @see AWS
* API Documentation
*/
@Override
public DeleteDatasetGroupResult deleteDatasetGroup(DeleteDatasetGroupRequest request) {
request = beforeClientExecution(request);
return executeDeleteDatasetGroup(request);
}
@SdkInternalApi
final DeleteDatasetGroupResult executeDeleteDatasetGroup(DeleteDatasetGroupRequest deleteDatasetGroupRequest) {
ExecutionContext executionContext = createExecutionContext(deleteDatasetGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteDatasetGroupRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteDatasetGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteDatasetGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteDatasetGroupResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a dataset import job created using the CreateDatasetImportJob
* operation. You can delete only dataset import jobs that have a status of ACTIVE or
* CREATE_FAILED. To get the status, use the DescribeDatasetImportJob operation.
*
*
* @param deleteDatasetImportJobRequest
* @return Result of the DeleteDatasetImportJob operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @throws ResourceInUseException
* The specified resource is in use.
* @sample AmazonForecast.DeleteDatasetImportJob
* @see AWS API Documentation
*/
@Override
public DeleteDatasetImportJobResult deleteDatasetImportJob(DeleteDatasetImportJobRequest request) {
request = beforeClientExecution(request);
return executeDeleteDatasetImportJob(request);
}
@SdkInternalApi
final DeleteDatasetImportJobResult executeDeleteDatasetImportJob(DeleteDatasetImportJobRequest deleteDatasetImportJobRequest) {
ExecutionContext executionContext = createExecutionContext(deleteDatasetImportJobRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteDatasetImportJobRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteDatasetImportJobRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteDatasetImportJob");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DeleteDatasetImportJobResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes an Explainability resource.
*
*
* You can delete only predictor that have a status of ACTIVE or CREATE_FAILED. To get the
* status, use the DescribeExplainability operation.
*
*
* @param deleteExplainabilityRequest
* @return Result of the DeleteExplainability operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @throws ResourceInUseException
* The specified resource is in use.
* @sample AmazonForecast.DeleteExplainability
* @see AWS
* API Documentation
*/
@Override
public DeleteExplainabilityResult deleteExplainability(DeleteExplainabilityRequest request) {
request = beforeClientExecution(request);
return executeDeleteExplainability(request);
}
@SdkInternalApi
final DeleteExplainabilityResult executeDeleteExplainability(DeleteExplainabilityRequest deleteExplainabilityRequest) {
ExecutionContext executionContext = createExecutionContext(deleteExplainabilityRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteExplainabilityRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteExplainabilityRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteExplainability");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteExplainabilityResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes an Explainability export.
*
*
* @param deleteExplainabilityExportRequest
* @return Result of the DeleteExplainabilityExport operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @throws ResourceInUseException
* The specified resource is in use.
* @sample AmazonForecast.DeleteExplainabilityExport
* @see AWS API Documentation
*/
@Override
public DeleteExplainabilityExportResult deleteExplainabilityExport(DeleteExplainabilityExportRequest request) {
request = beforeClientExecution(request);
return executeDeleteExplainabilityExport(request);
}
@SdkInternalApi
final DeleteExplainabilityExportResult executeDeleteExplainabilityExport(DeleteExplainabilityExportRequest deleteExplainabilityExportRequest) {
ExecutionContext executionContext = createExecutionContext(deleteExplainabilityExportRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteExplainabilityExportRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(deleteExplainabilityExportRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteExplainabilityExport");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DeleteExplainabilityExportResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a forecast created using the CreateForecast operation. You can delete only forecasts that have a
* status of ACTIVE or CREATE_FAILED. To get the status, use the DescribeForecast
* operation.
*
*
* You can't delete a forecast while it is being exported. After a forecast is deleted, you can no longer query the
* forecast.
*
*
* @param deleteForecastRequest
* @return Result of the DeleteForecast operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @throws ResourceInUseException
* The specified resource is in use.
* @sample AmazonForecast.DeleteForecast
* @see AWS API
* Documentation
*/
@Override
public DeleteForecastResult deleteForecast(DeleteForecastRequest request) {
request = beforeClientExecution(request);
return executeDeleteForecast(request);
}
@SdkInternalApi
final DeleteForecastResult executeDeleteForecast(DeleteForecastRequest deleteForecastRequest) {
ExecutionContext executionContext = createExecutionContext(deleteForecastRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteForecastRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteForecastRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteForecast");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteForecastResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a forecast export job created using the CreateForecastExportJob operation. You can delete only
* export jobs that have a status of ACTIVE or CREATE_FAILED. To get the status, use the
* DescribeForecastExportJob operation.
*
*
* @param deleteForecastExportJobRequest
* @return Result of the DeleteForecastExportJob operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @throws ResourceInUseException
* The specified resource is in use.
* @sample AmazonForecast.DeleteForecastExportJob
* @see AWS API Documentation
*/
@Override
public DeleteForecastExportJobResult deleteForecastExportJob(DeleteForecastExportJobRequest request) {
request = beforeClientExecution(request);
return executeDeleteForecastExportJob(request);
}
@SdkInternalApi
final DeleteForecastExportJobResult executeDeleteForecastExportJob(DeleteForecastExportJobRequest deleteForecastExportJobRequest) {
ExecutionContext executionContext = createExecutionContext(deleteForecastExportJobRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteForecastExportJobRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(deleteForecastExportJobRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteForecastExportJob");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DeleteForecastExportJobResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a monitor resource. You can only delete a monitor resource with a status of ACTIVE,
* ACTIVE_STOPPED, CREATE_FAILED, or CREATE_STOPPED.
*
*
* @param deleteMonitorRequest
* @return Result of the DeleteMonitor operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @throws ResourceInUseException
* The specified resource is in use.
* @sample AmazonForecast.DeleteMonitor
* @see AWS API
* Documentation
*/
@Override
public DeleteMonitorResult deleteMonitor(DeleteMonitorRequest request) {
request = beforeClientExecution(request);
return executeDeleteMonitor(request);
}
@SdkInternalApi
final DeleteMonitorResult executeDeleteMonitor(DeleteMonitorRequest deleteMonitorRequest) {
ExecutionContext executionContext = createExecutionContext(deleteMonitorRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteMonitorRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteMonitorRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteMonitor");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteMonitorResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a predictor created using the DescribePredictor or CreatePredictor operations. You can
* delete only predictor that have a status of ACTIVE or CREATE_FAILED. To get the status,
* use the DescribePredictor operation.
*
*
* @param deletePredictorRequest
* @return Result of the DeletePredictor operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @throws ResourceInUseException
* The specified resource is in use.
* @sample AmazonForecast.DeletePredictor
* @see AWS API
* Documentation
*/
@Override
public DeletePredictorResult deletePredictor(DeletePredictorRequest request) {
request = beforeClientExecution(request);
return executeDeletePredictor(request);
}
@SdkInternalApi
final DeletePredictorResult executeDeletePredictor(DeletePredictorRequest deletePredictorRequest) {
ExecutionContext executionContext = createExecutionContext(deletePredictorRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeletePredictorRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deletePredictorRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeletePredictor");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeletePredictorResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a predictor backtest export job.
*
*
* @param deletePredictorBacktestExportJobRequest
* @return Result of the DeletePredictorBacktestExportJob operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @throws ResourceInUseException
* The specified resource is in use.
* @sample AmazonForecast.DeletePredictorBacktestExportJob
* @see AWS API Documentation
*/
@Override
public DeletePredictorBacktestExportJobResult deletePredictorBacktestExportJob(DeletePredictorBacktestExportJobRequest request) {
request = beforeClientExecution(request);
return executeDeletePredictorBacktestExportJob(request);
}
@SdkInternalApi
final DeletePredictorBacktestExportJobResult executeDeletePredictorBacktestExportJob(
DeletePredictorBacktestExportJobRequest deletePredictorBacktestExportJobRequest) {
ExecutionContext executionContext = createExecutionContext(deletePredictorBacktestExportJobRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeletePredictorBacktestExportJobRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(deletePredictorBacktestExportJobRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeletePredictorBacktestExportJob");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DeletePredictorBacktestExportJobResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes an entire resource tree. This operation will delete the parent resource and its child resources.
*
*
* Child resources are resources that were created from another resource. For example, when a forecast is generated
* from a predictor, the forecast is the child resource and the predictor is the parent resource.
*
*
* Amazon Forecast resources possess the following parent-child resource hierarchies:
*
*
* -
*
* Dataset: dataset import jobs
*
*
* -
*
* Dataset Group: predictors, predictor backtest export jobs, forecasts, forecast export jobs
*
*
* -
*
* Predictor: predictor backtest export jobs, forecasts, forecast export jobs
*
*
* -
*
* Forecast: forecast export jobs
*
*
*
*
*
* DeleteResourceTree will only delete Amazon Forecast resources, and will not delete datasets or
* exported files stored in Amazon S3.
*
*
*
* @param deleteResourceTreeRequest
* @return Result of the DeleteResourceTree operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @throws ResourceInUseException
* The specified resource is in use.
* @sample AmazonForecast.DeleteResourceTree
* @see AWS
* API Documentation
*/
@Override
public DeleteResourceTreeResult deleteResourceTree(DeleteResourceTreeRequest request) {
request = beforeClientExecution(request);
return executeDeleteResourceTree(request);
}
@SdkInternalApi
final DeleteResourceTreeResult executeDeleteResourceTree(DeleteResourceTreeRequest deleteResourceTreeRequest) {
ExecutionContext executionContext = createExecutionContext(deleteResourceTreeRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteResourceTreeRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteResourceTreeRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteResourceTree");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteResourceTreeResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a what-if analysis created using the CreateWhatIfAnalysis operation. You can delete only what-if
* analyses that have a status of ACTIVE or CREATE_FAILED. To get the status, use the
* DescribeWhatIfAnalysis operation.
*
*
* You can't delete a what-if analysis while any of its forecasts are being exported.
*
*
* @param deleteWhatIfAnalysisRequest
* @return Result of the DeleteWhatIfAnalysis operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @throws ResourceInUseException
* The specified resource is in use.
* @sample AmazonForecast.DeleteWhatIfAnalysis
* @see AWS
* API Documentation
*/
@Override
public DeleteWhatIfAnalysisResult deleteWhatIfAnalysis(DeleteWhatIfAnalysisRequest request) {
request = beforeClientExecution(request);
return executeDeleteWhatIfAnalysis(request);
}
@SdkInternalApi
final DeleteWhatIfAnalysisResult executeDeleteWhatIfAnalysis(DeleteWhatIfAnalysisRequest deleteWhatIfAnalysisRequest) {
ExecutionContext executionContext = createExecutionContext(deleteWhatIfAnalysisRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteWhatIfAnalysisRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteWhatIfAnalysisRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteWhatIfAnalysis");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteWhatIfAnalysisResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a what-if forecast created using the CreateWhatIfForecast operation. You can delete only what-if
* forecasts that have a status of ACTIVE or CREATE_FAILED. To get the status, use the
* DescribeWhatIfForecast operation.
*
*
* You can't delete a what-if forecast while it is being exported. After a what-if forecast is deleted, you can no
* longer query the what-if analysis.
*
*
* @param deleteWhatIfForecastRequest
* @return Result of the DeleteWhatIfForecast operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @throws ResourceInUseException
* The specified resource is in use.
* @sample AmazonForecast.DeleteWhatIfForecast
* @see AWS
* API Documentation
*/
@Override
public DeleteWhatIfForecastResult deleteWhatIfForecast(DeleteWhatIfForecastRequest request) {
request = beforeClientExecution(request);
return executeDeleteWhatIfForecast(request);
}
@SdkInternalApi
final DeleteWhatIfForecastResult executeDeleteWhatIfForecast(DeleteWhatIfForecastRequest deleteWhatIfForecastRequest) {
ExecutionContext executionContext = createExecutionContext(deleteWhatIfForecastRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteWhatIfForecastRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteWhatIfForecastRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteWhatIfForecast");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteWhatIfForecastResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a what-if forecast export created using the CreateWhatIfForecastExport operation. You can delete
* only what-if forecast exports that have a status of ACTIVE or CREATE_FAILED. To get the
* status, use the DescribeWhatIfForecastExport operation.
*
*
* @param deleteWhatIfForecastExportRequest
* @return Result of the DeleteWhatIfForecastExport operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @throws ResourceInUseException
* The specified resource is in use.
* @sample AmazonForecast.DeleteWhatIfForecastExport
* @see AWS API Documentation
*/
@Override
public DeleteWhatIfForecastExportResult deleteWhatIfForecastExport(DeleteWhatIfForecastExportRequest request) {
request = beforeClientExecution(request);
return executeDeleteWhatIfForecastExport(request);
}
@SdkInternalApi
final DeleteWhatIfForecastExportResult executeDeleteWhatIfForecastExport(DeleteWhatIfForecastExportRequest deleteWhatIfForecastExportRequest) {
ExecutionContext executionContext = createExecutionContext(deleteWhatIfForecastExportRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteWhatIfForecastExportRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(deleteWhatIfForecastExportRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteWhatIfForecastExport");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DeleteWhatIfForecastExportResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Describes a predictor created using the CreateAutoPredictor operation.
*
*
* @param describeAutoPredictorRequest
* @return Result of the DescribeAutoPredictor operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @sample AmazonForecast.DescribeAutoPredictor
* @see AWS
* API Documentation
*/
@Override
public DescribeAutoPredictorResult describeAutoPredictor(DescribeAutoPredictorRequest request) {
request = beforeClientExecution(request);
return executeDescribeAutoPredictor(request);
}
@SdkInternalApi
final DescribeAutoPredictorResult executeDescribeAutoPredictor(DescribeAutoPredictorRequest describeAutoPredictorRequest) {
ExecutionContext executionContext = createExecutionContext(describeAutoPredictorRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeAutoPredictorRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeAutoPredictorRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeAutoPredictor");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeAutoPredictorResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Describes an Amazon Forecast dataset created using the CreateDataset operation.
*
*
* In addition to listing the parameters specified in the CreateDataset request, this operation
* includes the following dataset properties:
*
*
* -
*
* CreationTime
*
*
* -
*
* LastModificationTime
*
*
* -
*
* Status
*
*
*
*
* @param describeDatasetRequest
* @return Result of the DescribeDataset operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @sample AmazonForecast.DescribeDataset
* @see AWS API
* Documentation
*/
@Override
public DescribeDatasetResult describeDataset(DescribeDatasetRequest request) {
request = beforeClientExecution(request);
return executeDescribeDataset(request);
}
@SdkInternalApi
final DescribeDatasetResult executeDescribeDataset(DescribeDatasetRequest describeDatasetRequest) {
ExecutionContext executionContext = createExecutionContext(describeDatasetRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeDatasetRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeDatasetRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeDataset");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeDatasetResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Describes a dataset group created using the CreateDatasetGroup
* operation.
*
*
* In addition to listing the parameters provided in the CreateDatasetGroup request, this operation
* includes the following properties:
*
*
* -
*
* DatasetArns - The datasets belonging to the group.
*
*
* -
*
* CreationTime
*
*
* -
*
* LastModificationTime
*
*
* -
*
* Status
*
*
*
*
* @param describeDatasetGroupRequest
* @return Result of the DescribeDatasetGroup operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @sample AmazonForecast.DescribeDatasetGroup
* @see AWS
* API Documentation
*/
@Override
public DescribeDatasetGroupResult describeDatasetGroup(DescribeDatasetGroupRequest request) {
request = beforeClientExecution(request);
return executeDescribeDatasetGroup(request);
}
@SdkInternalApi
final DescribeDatasetGroupResult executeDescribeDatasetGroup(DescribeDatasetGroupRequest describeDatasetGroupRequest) {
ExecutionContext executionContext = createExecutionContext(describeDatasetGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeDatasetGroupRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeDatasetGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeDatasetGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeDatasetGroupResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Describes a dataset import job created using the CreateDatasetImportJob
* operation.
*
*
* In addition to listing the parameters provided in the CreateDatasetImportJob request, this operation
* includes the following properties:
*
*
* -
*
* CreationTime
*
*
* -
*
* LastModificationTime
*
*
* -
*
* DataSize
*
*
* -
*
* FieldStatistics
*
*
* -
*
* Status
*
*
* -
*
* Message - If an error occurred, information about the error.
*
*
*
*
* @param describeDatasetImportJobRequest
* @return Result of the DescribeDatasetImportJob operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @sample AmazonForecast.DescribeDatasetImportJob
* @see AWS API Documentation
*/
@Override
public DescribeDatasetImportJobResult describeDatasetImportJob(DescribeDatasetImportJobRequest request) {
request = beforeClientExecution(request);
return executeDescribeDatasetImportJob(request);
}
@SdkInternalApi
final DescribeDatasetImportJobResult executeDescribeDatasetImportJob(DescribeDatasetImportJobRequest describeDatasetImportJobRequest) {
ExecutionContext executionContext = createExecutionContext(describeDatasetImportJobRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeDatasetImportJobRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeDatasetImportJobRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeDatasetImportJob");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeDatasetImportJobResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Describes an Explainability resource created using the CreateExplainability operation.
*
*
* @param describeExplainabilityRequest
* @return Result of the DescribeExplainability operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @sample AmazonForecast.DescribeExplainability
* @see AWS API Documentation
*/
@Override
public DescribeExplainabilityResult describeExplainability(DescribeExplainabilityRequest request) {
request = beforeClientExecution(request);
return executeDescribeExplainability(request);
}
@SdkInternalApi
final DescribeExplainabilityResult executeDescribeExplainability(DescribeExplainabilityRequest describeExplainabilityRequest) {
ExecutionContext executionContext = createExecutionContext(describeExplainabilityRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeExplainabilityRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeExplainabilityRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeExplainability");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeExplainabilityResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Describes an Explainability export created using the CreateExplainabilityExport operation.
*
*
* @param describeExplainabilityExportRequest
* @return Result of the DescribeExplainabilityExport operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @sample AmazonForecast.DescribeExplainabilityExport
* @see AWS API Documentation
*/
@Override
public DescribeExplainabilityExportResult describeExplainabilityExport(DescribeExplainabilityExportRequest request) {
request = beforeClientExecution(request);
return executeDescribeExplainabilityExport(request);
}
@SdkInternalApi
final DescribeExplainabilityExportResult executeDescribeExplainabilityExport(DescribeExplainabilityExportRequest describeExplainabilityExportRequest) {
ExecutionContext executionContext = createExecutionContext(describeExplainabilityExportRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeExplainabilityExportRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeExplainabilityExportRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeExplainabilityExport");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeExplainabilityExportResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Describes a forecast created using the CreateForecast operation.
*
*
* In addition to listing the properties provided in the CreateForecast request, this operation lists
* the following properties:
*
*
* -
*
* DatasetGroupArn - The dataset group that provided the training data.
*
*
* -
*
* CreationTime
*
*
* -
*
* LastModificationTime
*
*
* -
*
* Status
*
*
* -
*
* Message - If an error occurred, information about the error.
*
*
*
*
* @param describeForecastRequest
* @return Result of the DescribeForecast operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @sample AmazonForecast.DescribeForecast
* @see AWS API
* Documentation
*/
@Override
public DescribeForecastResult describeForecast(DescribeForecastRequest request) {
request = beforeClientExecution(request);
return executeDescribeForecast(request);
}
@SdkInternalApi
final DescribeForecastResult executeDescribeForecast(DescribeForecastRequest describeForecastRequest) {
ExecutionContext executionContext = createExecutionContext(describeForecastRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeForecastRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeForecastRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeForecast");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeForecastResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Describes a forecast export job created using the CreateForecastExportJob operation.
*
*
* In addition to listing the properties provided by the user in the CreateForecastExportJob request,
* this operation lists the following properties:
*
*
* -
*
* CreationTime
*
*
* -
*
* LastModificationTime
*
*
* -
*
* Status
*
*
* -
*
* Message - If an error occurred, information about the error.
*
*
*
*
* @param describeForecastExportJobRequest
* @return Result of the DescribeForecastExportJob operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @sample AmazonForecast.DescribeForecastExportJob
* @see AWS API Documentation
*/
@Override
public DescribeForecastExportJobResult describeForecastExportJob(DescribeForecastExportJobRequest request) {
request = beforeClientExecution(request);
return executeDescribeForecastExportJob(request);
}
@SdkInternalApi
final DescribeForecastExportJobResult executeDescribeForecastExportJob(DescribeForecastExportJobRequest describeForecastExportJobRequest) {
ExecutionContext executionContext = createExecutionContext(describeForecastExportJobRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeForecastExportJobRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeForecastExportJobRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeForecastExportJob");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeForecastExportJobResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Describes a monitor resource. In addition to listing the properties provided in the CreateMonitor request,
* this operation lists the following properties:
*
*
* -
*
* Baseline
*
*
* -
*
* CreationTime
*
*
* -
*
* LastEvaluationTime
*
*
* -
*
* LastEvaluationState
*
*
* -
*
* LastModificationTime
*
*
* -
*
* Message
*
*
* -
*
* Status
*
*
*
*
* @param describeMonitorRequest
* @return Result of the DescribeMonitor operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @sample AmazonForecast.DescribeMonitor
* @see AWS API
* Documentation
*/
@Override
public DescribeMonitorResult describeMonitor(DescribeMonitorRequest request) {
request = beforeClientExecution(request);
return executeDescribeMonitor(request);
}
@SdkInternalApi
final DescribeMonitorResult executeDescribeMonitor(DescribeMonitorRequest describeMonitorRequest) {
ExecutionContext executionContext = createExecutionContext(describeMonitorRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeMonitorRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeMonitorRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeMonitor");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeMonitorResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
*
* This operation is only valid for legacy predictors created with CreatePredictor. If you are not using a legacy
* predictor, use DescribeAutoPredictor.
*
*
*
* Describes a predictor created using the CreatePredictor operation.
*
*
* In addition to listing the properties provided in the CreatePredictor request, this operation lists
* the following properties:
*
*
* -
*
* DatasetImportJobArns - The dataset import jobs used to import training data.
*
*
* -
*
* AutoMLAlgorithmArns - If AutoML is performed, the algorithms that were evaluated.
*
*
* -
*
* CreationTime
*
*
* -
*
* LastModificationTime
*
*
* -
*
* Status
*
*
* -
*
* Message - If an error occurred, information about the error.
*
*
*
*
* @param describePredictorRequest
* @return Result of the DescribePredictor operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @sample AmazonForecast.DescribePredictor
* @see AWS API
* Documentation
*/
@Override
public DescribePredictorResult describePredictor(DescribePredictorRequest request) {
request = beforeClientExecution(request);
return executeDescribePredictor(request);
}
@SdkInternalApi
final DescribePredictorResult executeDescribePredictor(DescribePredictorRequest describePredictorRequest) {
ExecutionContext executionContext = createExecutionContext(describePredictorRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribePredictorRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describePredictorRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribePredictor");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribePredictorResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Describes a predictor backtest export job created using the CreatePredictorBacktestExportJob operation.
*
*
* In addition to listing the properties provided by the user in the CreatePredictorBacktestExportJob
* request, this operation lists the following properties:
*
*
* -
*
* CreationTime
*
*
* -
*
* LastModificationTime
*
*
* -
*
* Status
*
*
* -
*
* Message (if an error occurred)
*
*
*
*
* @param describePredictorBacktestExportJobRequest
* @return Result of the DescribePredictorBacktestExportJob operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @sample AmazonForecast.DescribePredictorBacktestExportJob
* @see AWS API Documentation
*/
@Override
public DescribePredictorBacktestExportJobResult describePredictorBacktestExportJob(DescribePredictorBacktestExportJobRequest request) {
request = beforeClientExecution(request);
return executeDescribePredictorBacktestExportJob(request);
}
@SdkInternalApi
final DescribePredictorBacktestExportJobResult executeDescribePredictorBacktestExportJob(
DescribePredictorBacktestExportJobRequest describePredictorBacktestExportJobRequest) {
ExecutionContext executionContext = createExecutionContext(describePredictorBacktestExportJobRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribePredictorBacktestExportJobRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describePredictorBacktestExportJobRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribePredictorBacktestExportJob");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribePredictorBacktestExportJobResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Describes the what-if analysis created using the CreateWhatIfAnalysis operation.
*
*
* In addition to listing the properties provided in the CreateWhatIfAnalysis request, this operation
* lists the following properties:
*
*
* -
*
* CreationTime
*
*
* -
*
* LastModificationTime
*
*
* -
*
* Message - If an error occurred, information about the error.
*
*
* -
*
* Status
*
*
*
*
* @param describeWhatIfAnalysisRequest
* @return Result of the DescribeWhatIfAnalysis operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @sample AmazonForecast.DescribeWhatIfAnalysis
* @see AWS API Documentation
*/
@Override
public DescribeWhatIfAnalysisResult describeWhatIfAnalysis(DescribeWhatIfAnalysisRequest request) {
request = beforeClientExecution(request);
return executeDescribeWhatIfAnalysis(request);
}
@SdkInternalApi
final DescribeWhatIfAnalysisResult executeDescribeWhatIfAnalysis(DescribeWhatIfAnalysisRequest describeWhatIfAnalysisRequest) {
ExecutionContext executionContext = createExecutionContext(describeWhatIfAnalysisRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeWhatIfAnalysisRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeWhatIfAnalysisRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeWhatIfAnalysis");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeWhatIfAnalysisResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Describes the what-if forecast created using the CreateWhatIfForecast operation.
*
*
* In addition to listing the properties provided in the CreateWhatIfForecast request, this operation
* lists the following properties:
*
*
* -
*
* CreationTime
*
*
* -
*
* LastModificationTime
*
*
* -
*
* Message - If an error occurred, information about the error.
*
*
* -
*
* Status
*
*
*
*
* @param describeWhatIfForecastRequest
* @return Result of the DescribeWhatIfForecast operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @sample AmazonForecast.DescribeWhatIfForecast
* @see AWS API Documentation
*/
@Override
public DescribeWhatIfForecastResult describeWhatIfForecast(DescribeWhatIfForecastRequest request) {
request = beforeClientExecution(request);
return executeDescribeWhatIfForecast(request);
}
@SdkInternalApi
final DescribeWhatIfForecastResult executeDescribeWhatIfForecast(DescribeWhatIfForecastRequest describeWhatIfForecastRequest) {
ExecutionContext executionContext = createExecutionContext(describeWhatIfForecastRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeWhatIfForecastRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeWhatIfForecastRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeWhatIfForecast");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeWhatIfForecastResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Describes the what-if forecast export created using the CreateWhatIfForecastExport operation.
*
*
* In addition to listing the properties provided in the CreateWhatIfForecastExport request, this
* operation lists the following properties:
*
*
* -
*
* CreationTime
*
*
* -
*
* LastModificationTime
*
*
* -
*
* Message - If an error occurred, information about the error.
*
*
* -
*
* Status
*
*
*
*
* @param describeWhatIfForecastExportRequest
* @return Result of the DescribeWhatIfForecastExport operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @sample AmazonForecast.DescribeWhatIfForecastExport
* @see AWS API Documentation
*/
@Override
public DescribeWhatIfForecastExportResult describeWhatIfForecastExport(DescribeWhatIfForecastExportRequest request) {
request = beforeClientExecution(request);
return executeDescribeWhatIfForecastExport(request);
}
@SdkInternalApi
final DescribeWhatIfForecastExportResult executeDescribeWhatIfForecastExport(DescribeWhatIfForecastExportRequest describeWhatIfForecastExportRequest) {
ExecutionContext executionContext = createExecutionContext(describeWhatIfForecastExportRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeWhatIfForecastExportRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeWhatIfForecastExportRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeWhatIfForecastExport");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeWhatIfForecastExportResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Provides metrics on the accuracy of the models that were trained by the CreatePredictor operation. Use
* metrics to see how well the model performed and to decide whether to use the predictor to generate a forecast.
* For more information, see Predictor
* Metrics.
*
*
* This operation generates metrics for each backtest window that was evaluated. The number of backtest windows (
* NumberOfBacktestWindows) is specified using the EvaluationParameters object, which is
* optionally included in the CreatePredictor request. If NumberOfBacktestWindows isn't
* specified, the number defaults to one.
*
*
* The parameters of the filling method determine which items contribute to the metrics. If you want
* all items to contribute, specify zero. If you want only those items that have complete data in the
* range being evaluated to contribute, specify nan. For more information, see
* FeaturizationMethod.
*
*
*
* Before you can get accuracy metrics, the Status of the predictor must be ACTIVE,
* signifying that training has completed. To get the status, use the DescribePredictor operation.
*
*
*
* @param getAccuracyMetricsRequest
* @return Result of the GetAccuracyMetrics operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @throws ResourceInUseException
* The specified resource is in use.
* @sample AmazonForecast.GetAccuracyMetrics
* @see AWS
* API Documentation
*/
@Override
public GetAccuracyMetricsResult getAccuracyMetrics(GetAccuracyMetricsRequest request) {
request = beforeClientExecution(request);
return executeGetAccuracyMetrics(request);
}
@SdkInternalApi
final GetAccuracyMetricsResult executeGetAccuracyMetrics(GetAccuracyMetricsRequest getAccuracyMetricsRequest) {
ExecutionContext executionContext = createExecutionContext(getAccuracyMetricsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetAccuracyMetricsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getAccuracyMetricsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetAccuracyMetrics");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetAccuracyMetricsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a list of dataset groups created using the CreateDatasetGroup
* operation. For each dataset group, this operation returns a summary of its properties, including its Amazon
* Resource Name (ARN). You can retrieve the complete set of properties by using the dataset group ARN with the DescribeDatasetGroup
* operation.
*
*
* @param listDatasetGroupsRequest
* @return Result of the ListDatasetGroups operation returned by the service.
* @throws InvalidNextTokenException
* The token is not valid. Tokens expire after 24 hours.
* @sample AmazonForecast.ListDatasetGroups
* @see AWS API
* Documentation
*/
@Override
public ListDatasetGroupsResult listDatasetGroups(ListDatasetGroupsRequest request) {
request = beforeClientExecution(request);
return executeListDatasetGroups(request);
}
@SdkInternalApi
final ListDatasetGroupsResult executeListDatasetGroups(ListDatasetGroupsRequest listDatasetGroupsRequest) {
ExecutionContext executionContext = createExecutionContext(listDatasetGroupsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListDatasetGroupsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listDatasetGroupsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListDatasetGroups");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListDatasetGroupsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a list of dataset import jobs created using the CreateDatasetImportJob
* operation. For each import job, this operation returns a summary of its properties, including its Amazon Resource
* Name (ARN). You can retrieve the complete set of properties by using the ARN with the DescribeDatasetImportJob operation. You can filter the list by providing an array of Filter objects.
*
*
* @param listDatasetImportJobsRequest
* @return Result of the ListDatasetImportJobs operation returned by the service.
* @throws InvalidNextTokenException
* The token is not valid. Tokens expire after 24 hours.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @sample AmazonForecast.ListDatasetImportJobs
* @see AWS
* API Documentation
*/
@Override
public ListDatasetImportJobsResult listDatasetImportJobs(ListDatasetImportJobsRequest request) {
request = beforeClientExecution(request);
return executeListDatasetImportJobs(request);
}
@SdkInternalApi
final ListDatasetImportJobsResult executeListDatasetImportJobs(ListDatasetImportJobsRequest listDatasetImportJobsRequest) {
ExecutionContext executionContext = createExecutionContext(listDatasetImportJobsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListDatasetImportJobsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listDatasetImportJobsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListDatasetImportJobs");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ListDatasetImportJobsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a list of datasets created using the CreateDataset operation. For
* each dataset, a summary of its properties, including its Amazon Resource Name (ARN), is returned. To retrieve the
* complete set of properties, use the ARN with the DescribeDataset operation.
*
*
* @param listDatasetsRequest
* @return Result of the ListDatasets operation returned by the service.
* @throws InvalidNextTokenException
* The token is not valid. Tokens expire after 24 hours.
* @sample AmazonForecast.ListDatasets
* @see AWS API
* Documentation
*/
@Override
public ListDatasetsResult listDatasets(ListDatasetsRequest request) {
request = beforeClientExecution(request);
return executeListDatasets(request);
}
@SdkInternalApi
final ListDatasetsResult executeListDatasets(ListDatasetsRequest listDatasetsRequest) {
ExecutionContext executionContext = createExecutionContext(listDatasetsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListDatasetsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listDatasetsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListDatasets");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListDatasetsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a list of Explainability resources created using the CreateExplainability operation. This
* operation returns a summary for each Explainability. You can filter the list using an array of Filter
* objects.
*
*
* To retrieve the complete set of properties for a particular Explainability resource, use the ARN with the
* DescribeExplainability operation.
*
*
* @param listExplainabilitiesRequest
* @return Result of the ListExplainabilities operation returned by the service.
* @throws InvalidNextTokenException
* The token is not valid. Tokens expire after 24 hours.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @sample AmazonForecast.ListExplainabilities
* @see AWS
* API Documentation
*/
@Override
public ListExplainabilitiesResult listExplainabilities(ListExplainabilitiesRequest request) {
request = beforeClientExecution(request);
return executeListExplainabilities(request);
}
@SdkInternalApi
final ListExplainabilitiesResult executeListExplainabilities(ListExplainabilitiesRequest listExplainabilitiesRequest) {
ExecutionContext executionContext = createExecutionContext(listExplainabilitiesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListExplainabilitiesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listExplainabilitiesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListExplainabilities");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListExplainabilitiesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a list of Explainability exports created using the CreateExplainabilityExport operation. This
* operation returns a summary for each Explainability export. You can filter the list using an array of
* Filter objects.
*
*
* To retrieve the complete set of properties for a particular Explainability export, use the ARN with the
* DescribeExplainability operation.
*
*
* @param listExplainabilityExportsRequest
* @return Result of the ListExplainabilityExports operation returned by the service.
* @throws InvalidNextTokenException
* The token is not valid. Tokens expire after 24 hours.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @sample AmazonForecast.ListExplainabilityExports
* @see AWS API Documentation
*/
@Override
public ListExplainabilityExportsResult listExplainabilityExports(ListExplainabilityExportsRequest request) {
request = beforeClientExecution(request);
return executeListExplainabilityExports(request);
}
@SdkInternalApi
final ListExplainabilityExportsResult executeListExplainabilityExports(ListExplainabilityExportsRequest listExplainabilityExportsRequest) {
ExecutionContext executionContext = createExecutionContext(listExplainabilityExportsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListExplainabilityExportsRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(listExplainabilityExportsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListExplainabilityExports");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ListExplainabilityExportsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a list of forecast export jobs created using the CreateForecastExportJob operation. For each
* forecast export job, this operation returns a summary of its properties, including its Amazon Resource Name
* (ARN). To retrieve the complete set of properties, use the ARN with the DescribeForecastExportJob
* operation. You can filter the list using an array of Filter objects.
*
*
* @param listForecastExportJobsRequest
* @return Result of the ListForecastExportJobs operation returned by the service.
* @throws InvalidNextTokenException
* The token is not valid. Tokens expire after 24 hours.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @sample AmazonForecast.ListForecastExportJobs
* @see AWS API Documentation
*/
@Override
public ListForecastExportJobsResult listForecastExportJobs(ListForecastExportJobsRequest request) {
request = beforeClientExecution(request);
return executeListForecastExportJobs(request);
}
@SdkInternalApi
final ListForecastExportJobsResult executeListForecastExportJobs(ListForecastExportJobsRequest listForecastExportJobsRequest) {
ExecutionContext executionContext = createExecutionContext(listForecastExportJobsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListForecastExportJobsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listForecastExportJobsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListForecastExportJobs");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ListForecastExportJobsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a list of forecasts created using the CreateForecast operation. For each forecast, this operation
* returns a summary of its properties, including its Amazon Resource Name (ARN). To retrieve the complete set of
* properties, specify the ARN with the DescribeForecast operation. You can filter the list using an array of
* Filter objects.
*
*
* @param listForecastsRequest
* @return Result of the ListForecasts operation returned by the service.
* @throws InvalidNextTokenException
* The token is not valid. Tokens expire after 24 hours.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @sample AmazonForecast.ListForecasts
* @see AWS API
* Documentation
*/
@Override
public ListForecastsResult listForecasts(ListForecastsRequest request) {
request = beforeClientExecution(request);
return executeListForecasts(request);
}
@SdkInternalApi
final ListForecastsResult executeListForecasts(ListForecastsRequest listForecastsRequest) {
ExecutionContext executionContext = createExecutionContext(listForecastsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListForecastsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listForecastsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListForecasts");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListForecastsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a list of the monitoring evaluation results and predictor events collected by the monitor resource during
* different windows of time.
*
*
* For information about monitoring see predictor-monitoring. For more information about retrieving
* monitoring results see Viewing Monitoring
* Results.
*
*
* @param listMonitorEvaluationsRequest
* @return Result of the ListMonitorEvaluations operation returned by the service.
* @throws InvalidNextTokenException
* The token is not valid. Tokens expire after 24 hours.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @sample AmazonForecast.ListMonitorEvaluations
* @see AWS API Documentation
*/
@Override
public ListMonitorEvaluationsResult listMonitorEvaluations(ListMonitorEvaluationsRequest request) {
request = beforeClientExecution(request);
return executeListMonitorEvaluations(request);
}
@SdkInternalApi
final ListMonitorEvaluationsResult executeListMonitorEvaluations(ListMonitorEvaluationsRequest listMonitorEvaluationsRequest) {
ExecutionContext executionContext = createExecutionContext(listMonitorEvaluationsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListMonitorEvaluationsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listMonitorEvaluationsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListMonitorEvaluations");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ListMonitorEvaluationsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a list of monitors created with the CreateMonitor operation and CreateAutoPredictor
* operation. For each monitor resource, this operation returns of a summary of its properties, including its Amazon
* Resource Name (ARN). You can retrieve a complete set of properties of a monitor resource by specify the monitor's
* ARN in the DescribeMonitor operation.
*
*
* @param listMonitorsRequest
* @return Result of the ListMonitors operation returned by the service.
* @throws InvalidNextTokenException
* The token is not valid. Tokens expire after 24 hours.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @sample AmazonForecast.ListMonitors
* @see AWS API
* Documentation
*/
@Override
public ListMonitorsResult listMonitors(ListMonitorsRequest request) {
request = beforeClientExecution(request);
return executeListMonitors(request);
}
@SdkInternalApi
final ListMonitorsResult executeListMonitors(ListMonitorsRequest listMonitorsRequest) {
ExecutionContext executionContext = createExecutionContext(listMonitorsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListMonitorsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listMonitorsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListMonitors");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListMonitorsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a list of predictor backtest export jobs created using the CreatePredictorBacktestExportJob
* operation. This operation returns a summary for each backtest export job. You can filter the list using an array
* of Filter objects.
*
*
* To retrieve the complete set of properties for a particular backtest export job, use the ARN with the
* DescribePredictorBacktestExportJob operation.
*
*
* @param listPredictorBacktestExportJobsRequest
* @return Result of the ListPredictorBacktestExportJobs operation returned by the service.
* @throws InvalidNextTokenException
* The token is not valid. Tokens expire after 24 hours.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @sample AmazonForecast.ListPredictorBacktestExportJobs
* @see AWS API Documentation
*/
@Override
public ListPredictorBacktestExportJobsResult listPredictorBacktestExportJobs(ListPredictorBacktestExportJobsRequest request) {
request = beforeClientExecution(request);
return executeListPredictorBacktestExportJobs(request);
}
@SdkInternalApi
final ListPredictorBacktestExportJobsResult executeListPredictorBacktestExportJobs(
ListPredictorBacktestExportJobsRequest listPredictorBacktestExportJobsRequest) {
ExecutionContext executionContext = createExecutionContext(listPredictorBacktestExportJobsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListPredictorBacktestExportJobsRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(listPredictorBacktestExportJobsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListPredictorBacktestExportJobs");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ListPredictorBacktestExportJobsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a list of predictors created using the CreateAutoPredictor or CreatePredictor operations.
* For each predictor, this operation returns a summary of its properties, including its Amazon Resource Name (ARN).
*
*
* You can retrieve the complete set of properties by using the ARN with the DescribeAutoPredictor and
* DescribePredictor operations. You can filter the list using an array of Filter objects.
*
*
* @param listPredictorsRequest
* @return Result of the ListPredictors operation returned by the service.
* @throws InvalidNextTokenException
* The token is not valid. Tokens expire after 24 hours.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @sample AmazonForecast.ListPredictors
* @see AWS API
* Documentation
*/
@Override
public ListPredictorsResult listPredictors(ListPredictorsRequest request) {
request = beforeClientExecution(request);
return executeListPredictors(request);
}
@SdkInternalApi
final ListPredictorsResult executeListPredictors(ListPredictorsRequest listPredictorsRequest) {
ExecutionContext executionContext = createExecutionContext(listPredictorsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListPredictorsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listPredictorsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListPredictors");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListPredictorsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Lists the tags for an Amazon Forecast resource.
*
*
* @param listTagsForResourceRequest
* @return Result of the ListTagsForResource operation returned by the service.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @sample AmazonForecast.ListTagsForResource
* @see AWS
* API Documentation
*/
@Override
public ListTagsForResourceResult listTagsForResource(ListTagsForResourceRequest request) {
request = beforeClientExecution(request);
return executeListTagsForResource(request);
}
@SdkInternalApi
final ListTagsForResourceResult executeListTagsForResource(ListTagsForResourceRequest listTagsForResourceRequest) {
ExecutionContext executionContext = createExecutionContext(listTagsForResourceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListTagsForResourceRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listTagsForResourceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListTagsForResource");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListTagsForResourceResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a list of what-if analyses created using the CreateWhatIfAnalysis operation. For each what-if
* analysis, this operation returns a summary of its properties, including its Amazon Resource Name (ARN). You can
* retrieve the complete set of properties by using the what-if analysis ARN with the DescribeWhatIfAnalysis
* operation.
*
*
* @param listWhatIfAnalysesRequest
* @return Result of the ListWhatIfAnalyses operation returned by the service.
* @throws InvalidNextTokenException
* The token is not valid. Tokens expire after 24 hours.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @sample AmazonForecast.ListWhatIfAnalyses
* @see AWS
* API Documentation
*/
@Override
public ListWhatIfAnalysesResult listWhatIfAnalyses(ListWhatIfAnalysesRequest request) {
request = beforeClientExecution(request);
return executeListWhatIfAnalyses(request);
}
@SdkInternalApi
final ListWhatIfAnalysesResult executeListWhatIfAnalyses(ListWhatIfAnalysesRequest listWhatIfAnalysesRequest) {
ExecutionContext executionContext = createExecutionContext(listWhatIfAnalysesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListWhatIfAnalysesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listWhatIfAnalysesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListWhatIfAnalyses");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListWhatIfAnalysesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a list of what-if forecast exports created using the CreateWhatIfForecastExport operation. For
* each what-if forecast export, this operation returns a summary of its properties, including its Amazon Resource
* Name (ARN). You can retrieve the complete set of properties by using the what-if forecast export ARN with the
* DescribeWhatIfForecastExport operation.
*
*
* @param listWhatIfForecastExportsRequest
* @return Result of the ListWhatIfForecastExports operation returned by the service.
* @throws InvalidNextTokenException
* The token is not valid. Tokens expire after 24 hours.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @sample AmazonForecast.ListWhatIfForecastExports
* @see AWS API Documentation
*/
@Override
public ListWhatIfForecastExportsResult listWhatIfForecastExports(ListWhatIfForecastExportsRequest request) {
request = beforeClientExecution(request);
return executeListWhatIfForecastExports(request);
}
@SdkInternalApi
final ListWhatIfForecastExportsResult executeListWhatIfForecastExports(ListWhatIfForecastExportsRequest listWhatIfForecastExportsRequest) {
ExecutionContext executionContext = createExecutionContext(listWhatIfForecastExportsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListWhatIfForecastExportsRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(listWhatIfForecastExportsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListWhatIfForecastExports");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ListWhatIfForecastExportsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a list of what-if forecasts created using the CreateWhatIfForecast operation. For each what-if
* forecast, this operation returns a summary of its properties, including its Amazon Resource Name (ARN). You can
* retrieve the complete set of properties by using the what-if forecast ARN with the DescribeWhatIfForecast
* operation.
*
*
* @param listWhatIfForecastsRequest
* @return Result of the ListWhatIfForecasts operation returned by the service.
* @throws InvalidNextTokenException
* The token is not valid. Tokens expire after 24 hours.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @sample AmazonForecast.ListWhatIfForecasts
* @see AWS
* API Documentation
*/
@Override
public ListWhatIfForecastsResult listWhatIfForecasts(ListWhatIfForecastsRequest request) {
request = beforeClientExecution(request);
return executeListWhatIfForecasts(request);
}
@SdkInternalApi
final ListWhatIfForecastsResult executeListWhatIfForecasts(ListWhatIfForecastsRequest listWhatIfForecastsRequest) {
ExecutionContext executionContext = createExecutionContext(listWhatIfForecastsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListWhatIfForecastsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listWhatIfForecastsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListWhatIfForecasts");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListWhatIfForecastsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Resumes a stopped monitor resource.
*
*
* @param resumeResourceRequest
* @return Result of the ResumeResource operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws LimitExceededException
* The limit on the number of resources per account has been exceeded.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @throws ResourceInUseException
* The specified resource is in use.
* @sample AmazonForecast.ResumeResource
* @see AWS API
* Documentation
*/
@Override
public ResumeResourceResult resumeResource(ResumeResourceRequest request) {
request = beforeClientExecution(request);
return executeResumeResource(request);
}
@SdkInternalApi
final ResumeResourceResult executeResumeResource(ResumeResourceRequest resumeResourceRequest) {
ExecutionContext executionContext = createExecutionContext(resumeResourceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ResumeResourceRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(resumeResourceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ResumeResource");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ResumeResourceResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Stops a resource.
*
*
* The resource undergoes the following states: CREATE_STOPPING and CREATE_STOPPED. You
* cannot resume a resource once it has been stopped.
*
*
* This operation can be applied to the following resources (and their corresponding child resources):
*
*
* -
*
* Dataset Import Job
*
*
* -
*
* Predictor Job
*
*
* -
*
* Forecast Job
*
*
* -
*
* Forecast Export Job
*
*
* -
*
* Predictor Backtest Export Job
*
*
* -
*
* Explainability Job
*
*
* -
*
* Explainability Export Job
*
*
*
*
* @param stopResourceRequest
* @return Result of the StopResource operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws LimitExceededException
* The limit on the number of resources per account has been exceeded.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @sample AmazonForecast.StopResource
* @see AWS API
* Documentation
*/
@Override
public StopResourceResult stopResource(StopResourceRequest request) {
request = beforeClientExecution(request);
return executeStopResource(request);
}
@SdkInternalApi
final StopResourceResult executeStopResource(StopResourceRequest stopResourceRequest) {
ExecutionContext executionContext = createExecutionContext(stopResourceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new StopResourceRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(stopResourceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "StopResource");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new StopResourceResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Associates the specified tags to a resource with the specified resourceArn. If existing tags on a
* resource are not specified in the request parameters, they are not changed. When a resource is deleted, the tags
* associated with that resource are also deleted.
*
*
* @param tagResourceRequest
* @return Result of the TagResource operation returned by the service.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @throws LimitExceededException
* The limit on the number of resources per account has been exceeded.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @sample AmazonForecast.TagResource
* @see AWS API
* Documentation
*/
@Override
public TagResourceResult tagResource(TagResourceRequest request) {
request = beforeClientExecution(request);
return executeTagResource(request);
}
@SdkInternalApi
final TagResourceResult executeTagResource(TagResourceRequest tagResourceRequest) {
ExecutionContext executionContext = createExecutionContext(tagResourceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new TagResourceRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(tagResourceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "TagResource");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new TagResourceResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes the specified tags from a resource.
*
*
* @param untagResourceRequest
* @return Result of the UntagResource operation returned by the service.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @sample AmazonForecast.UntagResource
* @see AWS API
* Documentation
*/
@Override
public UntagResourceResult untagResource(UntagResourceRequest request) {
request = beforeClientExecution(request);
return executeUntagResource(request);
}
@SdkInternalApi
final UntagResourceResult executeUntagResource(UntagResourceRequest untagResourceRequest) {
ExecutionContext executionContext = createExecutionContext(untagResourceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UntagResourceRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(untagResourceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UntagResource");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new UntagResourceResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Replaces the datasets in a dataset group with the specified datasets.
*
*
*
* The Status of the dataset group must be ACTIVE before you can use the dataset group to
* create a predictor. Use the DescribeDatasetGroup
* operation to get the status.
*
*
*
* @param updateDatasetGroupRequest
* @return Result of the UpdateDatasetGroup operation returned by the service.
* @throws InvalidInputException
* We can't process the request because it includes an invalid value or a value that exceeds the valid
* range.
* @throws ResourceNotFoundException
* We can't find a resource with that Amazon Resource Name (ARN). Check the ARN and try again.
* @throws ResourceInUseException
* The specified resource is in use.
* @sample AmazonForecast.UpdateDatasetGroup
* @see AWS
* API Documentation
*/
@Override
public UpdateDatasetGroupResult updateDatasetGroup(UpdateDatasetGroupRequest request) {
request = beforeClientExecution(request);
return executeUpdateDatasetGroup(request);
}
@SdkInternalApi
final UpdateDatasetGroupResult executeUpdateDatasetGroup(UpdateDatasetGroupRequest updateDatasetGroupRequest) {
ExecutionContext executionContext = createExecutionContext(updateDatasetGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateDatasetGroupRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(updateDatasetGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "forecast");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateDatasetGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new UpdateDatasetGroupResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* Returns additional metadata for a previously executed successful, request, typically used for debugging issues
* where a service isn't acting as expected. This data isn't considered part of the result data returned by an
* operation, so it's available through this separate, diagnostic interface.
*
* Response metadata is only cached for a limited period of time, so if you need to access this extra diagnostic
* information for an executed request, you should use this method to retrieve it as soon as possible after
* executing the request.
*
* @param request
* The originally executed request
*
* @return The response metadata for the specified request, or null if none is available.
*/
public ResponseMetadata getCachedResponseMetadata(AmazonWebServiceRequest request) {
return client.getResponseMetadataForRequest(request);
}
/**
* Normal invoke with authentication. Credentials are required and may be overriden at the request level.
**/
private Response invoke(Request request, HttpResponseHandler> responseHandler,
ExecutionContext executionContext) {
return invoke(request, responseHandler, executionContext, null, null);
}
/**
* Normal invoke with authentication. Credentials are required and may be overriden at the request level.
**/
private Response invoke(Request request, HttpResponseHandler> responseHandler,
ExecutionContext executionContext, URI cachedEndpoint, URI uriFromEndpointTrait) {
executionContext.setCredentialsProvider(CredentialUtils.getCredentialsProvider(request.getOriginalRequest(), awsCredentialsProvider));
return doInvoke(request, responseHandler, executionContext, cachedEndpoint, uriFromEndpointTrait);
}
/**
* Invoke with no authentication. Credentials are not required and any credentials set on the client or request will
* be ignored for this operation.
**/
private Response anonymousInvoke(Request request,
HttpResponseHandler> responseHandler, ExecutionContext executionContext) {
return doInvoke(request, responseHandler, executionContext, null, null);
}
/**
* Invoke the request using the http client. Assumes credentials (or lack thereof) have been configured in the
* ExecutionContext beforehand.
**/
private Response doInvoke(Request request, HttpResponseHandler> responseHandler,
ExecutionContext executionContext, URI discoveredEndpoint, URI uriFromEndpointTrait) {
if (discoveredEndpoint != null) {
request.setEndpoint(discoveredEndpoint);
request.getOriginalRequest().getRequestClientOptions().appendUserAgent("endpoint-discovery");
} else if (uriFromEndpointTrait != null) {
request.setEndpoint(uriFromEndpointTrait);
} else {
request.setEndpoint(endpoint);
}
request.setTimeOffset(timeOffset);
HttpResponseHandler errorResponseHandler = protocolFactory.createErrorResponseHandler(new JsonErrorResponseMetadata());
return client.execute(request, responseHandler, errorResponseHandler, executionContext);
}
@com.amazonaws.annotation.SdkInternalApi
static com.amazonaws.protocol.json.SdkJsonProtocolFactory getProtocolFactory() {
return protocolFactory;
}
@Override
public void shutdown() {
super.shutdown();
}
}