1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208
|
// Code generated by smithy-go-codegen DO NOT EDIT.
package lookoutvision
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/aws-sdk-go-v2/service/lookoutvision/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a new dataset in an Amazon Lookout for Vision project. CreateDataset
// can create a training or a test dataset from a valid dataset source (
// DatasetSource ). If you want a single dataset project, specify train for the
// value of DatasetType . To have a project with separate training and test
// datasets, call CreateDataset twice. On the first call, specify train for the
// value of DatasetType . On the second call, specify test for the value of
// DatasetType . This operation requires permissions to perform the
// lookoutvision:CreateDataset operation.
func (c *Client) CreateDataset(ctx context.Context, params *CreateDatasetInput, optFns ...func(*Options)) (*CreateDatasetOutput, error) {
if params == nil {
params = &CreateDatasetInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateDataset", params, optFns, c.addOperationCreateDatasetMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateDatasetOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateDatasetInput struct {
// The type of the dataset. Specify train for a training dataset. Specify test for
// a test dataset.
//
// This member is required.
DatasetType *string
// The name of the project in which you want to create a dataset.
//
// This member is required.
ProjectName *string
// ClientToken is an idempotency token that ensures a call to CreateDataset
// completes only once. You choose the value to pass. For example, An issue might
// prevent you from getting a response from CreateDataset . In this case, safely
// retry your call to CreateDataset by using the same ClientToken parameter value.
// If you don't supply a value for ClientToken , the AWS SDK you are using inserts
// a value for you. This prevents retries after a network error from making
// multiple dataset creation requests. You'll need to provide your own value for
// other use cases. An error occurs if the other input parameters are not the same
// as in the first request. Using a different value for ClientToken is considered
// a new call to CreateDataset . An idempotency token is active for 8 hours.
ClientToken *string
// The location of the manifest file that Amazon Lookout for Vision uses to create
// the dataset. If you don't specify DatasetSource , an empty dataset is created
// and the operation synchronously returns. Later, you can add JSON Lines by
// calling UpdateDatasetEntries . If you specify a value for DataSource , the
// manifest at the S3 location is validated and used to create the dataset. The
// call to CreateDataset is asynchronous and might take a while to complete. To
// find out the current status, Check the value of Status returned in a call to
// DescribeDataset .
DatasetSource *types.DatasetSource
noSmithyDocumentSerde
}
type CreateDatasetOutput struct {
// Information about the dataset.
DatasetMetadata *types.DatasetMetadata
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateDatasetMiddlewares(stack *middleware.Stack, options Options) (err error) {
if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil {
return err
}
err = stack.Serialize.Add(&awsRestjson1_serializeOpCreateDataset{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsRestjson1_deserializeOpCreateDataset{}, middleware.After)
if err != nil {
return err
}
if err := addProtocolFinalizerMiddlewares(stack, options, "CreateDataset"); err != nil {
return fmt.Errorf("add protocol finalizers: %v", err)
}
if err = addlegacyEndpointContextSetter(stack, options); err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
return err
}
if err = addRetryMiddlewares(stack, options); err != nil {
return err
}
if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
return err
}
if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack, options); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil {
return err
}
if err = addIdempotencyToken_opCreateDatasetMiddleware(stack, options); err != nil {
return err
}
if err = addOpCreateDatasetValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateDataset(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
if err = addDisableHTTPSMiddleware(stack, options); err != nil {
return err
}
return nil
}
type idempotencyToken_initializeOpCreateDataset struct {
tokenProvider IdempotencyTokenProvider
}
func (*idempotencyToken_initializeOpCreateDataset) ID() string {
return "OperationIdempotencyTokenAutoFill"
}
func (m *idempotencyToken_initializeOpCreateDataset) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
if m.tokenProvider == nil {
return next.HandleInitialize(ctx, in)
}
input, ok := in.Parameters.(*CreateDatasetInput)
if !ok {
return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateDatasetInput ")
}
if input.ClientToken == nil {
t, err := m.tokenProvider.GetIdempotencyToken()
if err != nil {
return out, metadata, err
}
input.ClientToken = &t
}
return next.HandleInitialize(ctx, in)
}
func addIdempotencyToken_opCreateDatasetMiddleware(stack *middleware.Stack, cfg Options) error {
return stack.Initialize.Add(&idempotencyToken_initializeOpCreateDataset{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before)
}
func newServiceMetadataMiddleware_opCreateDataset(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
OperationName: "CreateDataset",
}
}
|