robocars/robocar-tools
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

feat(train): add new command to interact with aws and train models

Browse Source
This commit is contained in:
Cyrille Nofficial
2021-10-17 19:15:44 +02:00
parent 5436dfebc2
commit 538cea18f2
1064 changed files with 282251 additions and 89305 deletions
Download Patch File Download Diff File Expand all files Collapse all files

55
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/CHANGELOG.md generated vendored Normal file
View File

@@ -0,0 +1,55 @@
# v1.15.0 (2021-09-17)
* **Feature**: Updated API client and endpoints to latest revision.
* **Dependency Update**: Updated to the latest SDK module versions
# v1.14.0 (2021-09-10)
* **Feature**: API client updated
# v1.13.0 (2021-08-27)
* **Feature**: Updated `github.com/aws/smithy-go` to latest version
* **Dependency Update**: Updated to the latest SDK module versions
# v1.12.0 (2021-08-19)
* **Feature**: API client updated
* **Dependency Update**: Updated to the latest SDK module versions
# v1.11.0 (2021-08-04)
* **Feature**: Updated to latest API model.
* **Dependency Update**: Updated `github.com/aws/smithy-go` to latest version.
* **Dependency Update**: Updated to the latest SDK module versions
# v1.10.0 (2021-07-15)
* **Feature**: Updated service model to latest version.
* **Dependency Update**: Updated `github.com/aws/smithy-go` to latest version
* **Dependency Update**: Updated to the latest SDK module versions
# v1.9.0 (2021-07-01)
* **Feature**: API client updated
# v1.8.0 (2021-06-25)
* **Feature**: API client updated
* **Feature**: Updated `github.com/aws/smithy-go` to latest version
* **Dependency Update**: Updated to the latest SDK module versions
# v1.7.0 (2021-06-11)
* **Feature**: Updated to latest API model.
# v1.6.0 (2021-05-20)
* **Feature**: API client updated
* **Dependency Update**: Updated to the latest SDK module versions
# v1.5.0 (2021-05-14)
* **Feature**: Constant has been added to modules to enable runtime version inspection for reporting.
* **Dependency Update**: Updated to the latest SDK module versions

202
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/LICENSE.txt generated vendored Normal file
View File

@@ -0,0 +1,202 @@
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License 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.

282
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_client.go generated vendored Normal file
View File

@@ -0,0 +1,282 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
cryptorand "crypto/rand"
"github.com/aws/aws-sdk-go-v2/aws"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/retry"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
awshttp "github.com/aws/aws-sdk-go-v2/aws/transport/http"
smithy "github.com/aws/smithy-go"
smithydocument "github.com/aws/smithy-go/document"
"github.com/aws/smithy-go/logging"
"github.com/aws/smithy-go/middleware"
smithyrand "github.com/aws/smithy-go/rand"
smithyhttp "github.com/aws/smithy-go/transport/http"
"net/http"
"time"
)
const ServiceID = "SageMaker"
const ServiceAPIVersion = "2017-07-24"
// Client provides the API client to make operations call for Amazon SageMaker
// Service.
type Client struct {
options Options
}
// New returns an initialized Client based on the functional options. Provide
// additional functional options to further configure the behavior of the client,
// such as changing the client's endpoint or adding custom middleware behavior.
func New(options Options, optFns ...func(*Options)) *Client {
options = options.Copy()
resolveDefaultLogger(&options)
resolveRetryer(&options)
resolveHTTPClient(&options)
resolveHTTPSignerV4(&options)
resolveDefaultEndpointConfiguration(&options)
resolveIdempotencyTokenProvider(&options)
for _, fn := range optFns {
fn(&options)
}
client := &Client{
options: options,
}
return client
}
type Options struct {
// Set of options to modify how an operation is invoked. These apply to all
// operations invoked for this client. Use functional options on operation call to
// modify this list for per operation behavior.
APIOptions []func(*middleware.Stack) error
// Configures the events that will be sent to the configured logger.
ClientLogMode aws.ClientLogMode
// The credentials object to use when signing requests.
Credentials aws.CredentialsProvider
// The endpoint options to be used when attempting to resolve an endpoint.
EndpointOptions EndpointResolverOptions
// The service endpoint resolver.
EndpointResolver EndpointResolver
// Signature Version 4 (SigV4) Signer
HTTPSignerV4 HTTPSignerV4
// Provides idempotency tokens values that will be automatically populated into
// idempotent API operations.
IdempotencyTokenProvider IdempotencyTokenProvider
// The logger writer interface to write logging messages to.
Logger logging.Logger
// The region to send requests to. (Required)
Region string
// Retryer guides how HTTP requests should be retried in case of recoverable
// failures. When nil the API client will use a default retryer.
Retryer aws.Retryer
// The HTTP client to invoke API calls with. Defaults to client's default HTTP
// implementation if nil.
HTTPClient HTTPClient
}
// WithAPIOptions returns a functional option for setting the Client's APIOptions
// option.
func WithAPIOptions(optFns ...func(*middleware.Stack) error) func(*Options) {
return func(o *Options) {
o.APIOptions = append(o.APIOptions, optFns...)
}
}
// WithEndpointResolver returns a functional option for setting the Client's
// EndpointResolver option.
func WithEndpointResolver(v EndpointResolver) func(*Options) {
return func(o *Options) {
o.EndpointResolver = v
}
}
type HTTPClient interface {
Do(*http.Request) (*http.Response, error)
}
// Copy creates a clone where the APIOptions list is deep copied.
func (o Options) Copy() Options {
to := o
to.APIOptions = make([]func(*middleware.Stack) error, len(o.APIOptions))
copy(to.APIOptions, o.APIOptions)
return to
}
func (c *Client) invokeOperation(ctx context.Context, opID string, params interface{}, optFns []func(*Options), stackFns ...func(*middleware.Stack, Options) error) (result interface{}, metadata middleware.Metadata, err error) {
ctx = middleware.ClearStackValues(ctx)
stack := middleware.NewStack(opID, smithyhttp.NewStackRequest)
options := c.options.Copy()
for _, fn := range optFns {
fn(&options)
}
for _, fn := range stackFns {
if err := fn(stack, options); err != nil {
return nil, metadata, err
}
}
for _, fn := range options.APIOptions {
if err := fn(stack); err != nil {
return nil, metadata, err
}
}
handler := middleware.DecorateHandler(smithyhttp.NewClientHandler(options.HTTPClient), stack)
result, metadata, err = handler.Handle(ctx, params)
if err != nil {
err = &smithy.OperationError{
ServiceID: ServiceID,
OperationName: opID,
Err: err,
}
}
return result, metadata, err
}
type noSmithyDocumentSerde = smithydocument.NoSerde
func resolveDefaultLogger(o *Options) {
if o.Logger != nil {
return
}
o.Logger = logging.Nop{}
}
func addSetLoggerMiddleware(stack *middleware.Stack, o Options) error {
return middleware.AddSetLoggerMiddleware(stack, o.Logger)
}
// NewFromConfig returns a new client from the provided config.
func NewFromConfig(cfg aws.Config, optFns ...func(*Options)) *Client {
opts := Options{
Region: cfg.Region,
HTTPClient: cfg.HTTPClient,
Credentials: cfg.Credentials,
APIOptions: cfg.APIOptions,
Logger: cfg.Logger,
ClientLogMode: cfg.ClientLogMode,
}
resolveAWSRetryerProvider(cfg, &opts)
resolveAWSEndpointResolver(cfg, &opts)
return New(opts, optFns...)
}
func resolveHTTPClient(o *Options) {
if o.HTTPClient != nil {
return
}
o.HTTPClient = awshttp.NewBuildableClient()
}
func resolveRetryer(o *Options) {
if o.Retryer != nil {
return
}
o.Retryer = retry.NewStandard()
}
func resolveAWSRetryerProvider(cfg aws.Config, o *Options) {
if cfg.Retryer == nil {
return
}
o.Retryer = cfg.Retryer()
}
func resolveAWSEndpointResolver(cfg aws.Config, o *Options) {
if cfg.EndpointResolver == nil {
return
}
o.EndpointResolver = withEndpointResolver(cfg.EndpointResolver, NewDefaultEndpointResolver())
}
func addClientUserAgent(stack *middleware.Stack) error {
return awsmiddleware.AddSDKAgentKeyValue(awsmiddleware.APIMetadata, "sagemaker", goModuleVersion)(stack)
}
func addHTTPSignerV4Middleware(stack *middleware.Stack, o Options) error {
mw := v4.NewSignHTTPRequestMiddleware(v4.SignHTTPRequestMiddlewareOptions{
CredentialsProvider: o.Credentials,
Signer: o.HTTPSignerV4,
LogSigning: o.ClientLogMode.IsSigning(),
})
return stack.Finalize.Add(mw, middleware.After)
}
type HTTPSignerV4 interface {
SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time, optFns ...func(*v4.SignerOptions)) error
}
func resolveHTTPSignerV4(o *Options) {
if o.HTTPSignerV4 != nil {
return
}
o.HTTPSignerV4 = newDefaultV4Signer(*o)
}
func newDefaultV4Signer(o Options) *v4.Signer {
return v4.NewSigner(func(so *v4.SignerOptions) {
so.Logger = o.Logger
so.LogSigning = o.ClientLogMode.IsSigning()
})
}
func resolveIdempotencyTokenProvider(o *Options) {
if o.IdempotencyTokenProvider != nil {
return
}
o.IdempotencyTokenProvider = smithyrand.NewUUIDIdempotencyToken(cryptorand.Reader)
}
func addRetryMiddlewares(stack *middleware.Stack, o Options) error {
mo := retry.AddRetryMiddlewaresOptions{
Retryer: o.Retryer,
LogRetryAttempts: o.ClientLogMode.IsRetries(),
}
return retry.AddRetryMiddlewares(stack, mo)
}
// IdempotencyTokenProvider interface for providing idempotency token
type IdempotencyTokenProvider interface {
GetIdempotencyToken() (string, error)
}
func addRequestIDRetrieverMiddleware(stack *middleware.Stack) error {
return awsmiddleware.AddRequestIDRetrieverMiddleware(stack)
}
func addResponseErrorMiddleware(stack *middleware.Stack) error {
return awshttp.AddResponseErrorMiddleware(stack)
}
func addRequestResponseLogging(stack *middleware.Stack, o Options) error {
return stack.Deserialize.Add(&smithyhttp.RequestResponseLogger{
LogRequest: o.ClientLogMode.IsRequest(),
LogRequestWithBody: o.ClientLogMode.IsRequestWithBody(),
LogResponse: o.ClientLogMode.IsResponse(),
LogResponseWithBody: o.ClientLogMode.IsResponseWithBody(),
}, middleware.After)
}

153
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_AddAssociation.go generated vendored Normal file
View File

@@ -0,0 +1,153 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates an association between the source and the destination. A source can be
// associated with multiple destinations, and a destination can be associated with
// multiple sources. An association is a lineage tracking entity. For more
// information, see Amazon SageMaker ML Lineage Tracking
// (https://docs.aws.amazon.com/sagemaker/latest/dg/lineage-tracking.html).
func (c *Client) AddAssociation(ctx context.Context, params *AddAssociationInput, optFns ...func(*Options)) (*AddAssociationOutput, error) {
if params == nil {
params = &AddAssociationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "AddAssociation", params, optFns, c.addOperationAddAssociationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*AddAssociationOutput)
out.ResultMetadata = metadata
return out, nil
}
type AddAssociationInput struct {
// The Amazon Resource Name (ARN) of the destination.
//
// This member is required.
DestinationArn *string
// The ARN of the source.
//
// This member is required.
SourceArn *string
// The type of association. The following are suggested uses for each type. Amazon
// SageMaker places no restrictions on their use.
//
// * ContributedTo - The source
// contributed to the destination or had a part in enabling the destination. For
// example, the training data contributed to the training job.
//
// * AssociatedWith -
// The source is connected to the destination. For example, an approval workflow is
// associated with a model deployment.
//
// * DerivedFrom - The destination is a
// modification of the source. For example, a digest output of a channel input for
// a processing job is derived from the original inputs.
//
// * Produced - The source
// generated the destination. For example, a training job produced a model
// artifact.
AssociationType types.AssociationEdgeType
noSmithyDocumentSerde
}
type AddAssociationOutput struct {
// The Amazon Resource Name (ARN) of the destination.
DestinationArn *string
// The ARN of the source.
SourceArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationAddAssociationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpAddAssociation{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpAddAssociation{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpAddAssociationValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opAddAssociation(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opAddAssociation(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "AddAssociation",
}
}

150
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_AddTags.go generated vendored Normal file
View File

@@ -0,0 +1,150 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Adds or overwrites one or more tags for the specified Amazon SageMaker resource.
// You can add tags to notebook instances, training jobs, hyperparameter tuning
// jobs, batch transform jobs, models, labeling jobs, work teams, endpoint
// configurations, and endpoints. Each tag consists of a key and an optional value.
// Tag keys must be unique per resource. For more information about tags, see For
// more information, see Amazon Web Services Tagging Strategies
// (https://aws.amazon.com/answers/account-management/aws-tagging-strategies/).
// Tags that you add to a hyperparameter tuning job by calling this API are also
// added to any training jobs that the hyperparameter tuning job launches after you
// call this API, but not to training jobs that the hyperparameter tuning job
// launched before you called this API. To make sure that the tags associated with
// a hyperparameter tuning job are also added to all training jobs that the
// hyperparameter tuning job launches, add the tags when you first create the
// tuning job by specifying them in the Tags parameter of
// CreateHyperParameterTuningJob Tags that you add to a SageMaker Studio Domain or
// User Profile by calling this API are also added to any Apps that the Domain or
// User Profile launches after you call this API, but not to Apps that the Domain
// or User Profile launched before you called this API. To make sure that the tags
// associated with a Domain or User Profile are also added to all Apps that the
// Domain or User Profile launches, add the tags when you first create the Domain
// or User Profile by specifying them in the Tags parameter of CreateDomain or
// CreateUserProfile.
func (c *Client) AddTags(ctx context.Context, params *AddTagsInput, optFns ...func(*Options)) (*AddTagsOutput, error) {
if params == nil {
params = &AddTagsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "AddTags", params, optFns, c.addOperationAddTagsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*AddTagsOutput)
out.ResultMetadata = metadata
return out, nil
}
type AddTagsInput struct {
// The Amazon Resource Name (ARN) of the resource that you want to tag.
//
// This member is required.
ResourceArn *string
// An array of key-value pairs. You can use tags to categorize your Amazon Web
// Services resources in different ways, for example, by purpose, owner, or
// environment. For more information, see Tagging Amazon Web Services Resources
// (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html).
//
// This member is required.
Tags []types.Tag
noSmithyDocumentSerde
}
type AddTagsOutput struct {
// A list of tags associated with the Amazon SageMaker resource.
Tags []types.Tag
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationAddTagsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpAddTags{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpAddTags{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpAddTagsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opAddTags(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opAddTags(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "AddTags",
}
}

130
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_AssociateTrialComponent.go generated vendored Normal file
View File

@@ -0,0 +1,130 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Associates a trial component with a trial. A trial component can be associated
// with multiple trials. To disassociate a trial component from a trial, call the
// DisassociateTrialComponent API.
func (c *Client) AssociateTrialComponent(ctx context.Context, params *AssociateTrialComponentInput, optFns ...func(*Options)) (*AssociateTrialComponentOutput, error) {
if params == nil {
params = &AssociateTrialComponentInput{}
}
result, metadata, err := c.invokeOperation(ctx, "AssociateTrialComponent", params, optFns, c.addOperationAssociateTrialComponentMiddlewares)
if err != nil {
return nil, err
}
out := result.(*AssociateTrialComponentOutput)
out.ResultMetadata = metadata
return out, nil
}
type AssociateTrialComponentInput struct {
// The name of the component to associated with the trial.
//
// This member is required.
TrialComponentName *string
// The name of the trial to associate with.
//
// This member is required.
TrialName *string
noSmithyDocumentSerde
}
type AssociateTrialComponentOutput struct {
// The Amazon Resource Name (ARN) of the trial.
TrialArn *string
// The ARN of the trial component.
TrialComponentArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationAssociateTrialComponentMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpAssociateTrialComponent{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpAssociateTrialComponent{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpAssociateTrialComponentValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opAssociateTrialComponent(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opAssociateTrialComponent(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "AssociateTrialComponent",
}
}

151
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateAction.go generated vendored Normal file
View File

@@ -0,0 +1,151 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates an action. An action is a lineage tracking entity that represents an
// action or activity. For example, a model deployment or an HPO job. Generally, an
// action involves at least one input or output artifact. For more information, see
// Amazon SageMaker ML Lineage Tracking
// (https://docs.aws.amazon.com/sagemaker/latest/dg/lineage-tracking.html).
func (c *Client) CreateAction(ctx context.Context, params *CreateActionInput, optFns ...func(*Options)) (*CreateActionOutput, error) {
if params == nil {
params = &CreateActionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateAction", params, optFns, c.addOperationCreateActionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateActionOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateActionInput struct {
// The name of the action. Must be unique to your account in an Amazon Web Services
// Region.
//
// This member is required.
ActionName *string
// The action type.
//
// This member is required.
ActionType *string
// The source type, ID, and URI.
//
// This member is required.
Source *types.ActionSource
// The description of the action.
Description *string
// Metadata properties of the tracking entity, trial, or trial component.
MetadataProperties *types.MetadataProperties
// A list of properties to add to the action.
Properties map[string]string
// The status of the action.
Status types.ActionStatus
// A list of tags to apply to the action.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateActionOutput struct {
// The Amazon Resource Name (ARN) of the action.
ActionArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateActionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateAction{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateAction{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateActionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateAction(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreateAction(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateAction",
}
}

183
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateAlgorithm.go generated vendored Normal file
View File

@@ -0,0 +1,183 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Create a machine learning algorithm that you can use in Amazon SageMaker and
// list in the Amazon Web Services Marketplace.
func (c *Client) CreateAlgorithm(ctx context.Context, params *CreateAlgorithmInput, optFns ...func(*Options)) (*CreateAlgorithmOutput, error) {
if params == nil {
params = &CreateAlgorithmInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateAlgorithm", params, optFns, c.addOperationCreateAlgorithmMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateAlgorithmOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateAlgorithmInput struct {
// The name of the algorithm.
//
// This member is required.
AlgorithmName *string
// Specifies details about training jobs run by this algorithm, including the
// following:
//
// * The Amazon ECR path of the container and the version digest of the
// algorithm.
//
// * The hyperparameters that the algorithm supports.
//
// * The instance
// types that the algorithm supports for training.
//
// * Whether the algorithm
// supports distributed training.
//
// * The metrics that the algorithm emits to Amazon
// CloudWatch.
//
// * Which metrics that the algorithm emits can be used as the
// objective metric for hyperparameter tuning jobs.
//
// * The input channels that the
// algorithm supports for training data. For example, an algorithm might support
// train, validation, and test channels.
//
// This member is required.
TrainingSpecification *types.TrainingSpecification
// A description of the algorithm.
AlgorithmDescription *string
// Whether to certify the algorithm so that it can be listed in Amazon Web Services
// Marketplace.
CertifyForMarketplace bool
// Specifies details about inference jobs that the algorithm runs, including the
// following:
//
// * The Amazon ECR paths of containers that contain the inference code
// and model artifacts.
//
// * The instance types that the algorithm supports for
// transform jobs and real-time endpoints used for inference.
//
// * The input and
// output content formats that the algorithm supports for inference.
InferenceSpecification *types.InferenceSpecification
// An array of key-value pairs. You can use tags to categorize your Amazon Web
// Services resources in different ways, for example, by purpose, owner, or
// environment. For more information, see Tagging Amazon Web Services Resources
// (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html).
Tags []types.Tag
// Specifies configurations for one or more training jobs and that Amazon SageMaker
// runs to test the algorithm's training code and, optionally, one or more batch
// transform jobs that Amazon SageMaker runs to test the algorithm's inference
// code.
ValidationSpecification *types.AlgorithmValidationSpecification
noSmithyDocumentSerde
}
type CreateAlgorithmOutput struct {
// The Amazon Resource Name (ARN) of the new algorithm.
//
// This member is required.
AlgorithmArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateAlgorithmMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateAlgorithm{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateAlgorithm{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateAlgorithmValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateAlgorithm(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreateAlgorithm(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateAlgorithm",
}
}

149
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateApp.go generated vendored Normal file
View File

@@ -0,0 +1,149 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a running app for the specified UserProfile. Supported apps are
// JupyterServer and KernelGateway. This operation is automatically invoked by
// Amazon SageMaker Studio upon access to the associated Domain, and when new
// kernel configurations are selected by the user. A user may have multiple Apps
// active simultaneously.
func (c *Client) CreateApp(ctx context.Context, params *CreateAppInput, optFns ...func(*Options)) (*CreateAppOutput, error) {
if params == nil {
params = &CreateAppInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateApp", params, optFns, c.addOperationCreateAppMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateAppOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateAppInput struct {
// The name of the app.
//
// This member is required.
AppName *string
// The type of app. Supported apps are JupyterServer and KernelGateway. TensorBoard
// is not supported.
//
// This member is required.
AppType types.AppType
// The domain ID.
//
// This member is required.
DomainId *string
// The user profile name.
//
// This member is required.
UserProfileName *string
// The instance type and the Amazon Resource Name (ARN) of the SageMaker image
// created on the instance.
ResourceSpec *types.ResourceSpec
// Each tag consists of a key and an optional value. Tag keys must be unique per
// resource.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateAppOutput struct {
// The Amazon Resource Name (ARN) of the app.
AppArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateAppMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateApp{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateApp{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateAppValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateApp(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreateApp(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateApp",
}
}

129
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateAppImageConfig.go generated vendored Normal file
View File

@@ -0,0 +1,129 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a configuration for running a SageMaker image as a KernelGateway app.
// The configuration specifies the Amazon Elastic File System (EFS) storage volume
// on the image, and a list of the kernels in the image.
func (c *Client) CreateAppImageConfig(ctx context.Context, params *CreateAppImageConfigInput, optFns ...func(*Options)) (*CreateAppImageConfigOutput, error) {
if params == nil {
params = &CreateAppImageConfigInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateAppImageConfig", params, optFns, c.addOperationCreateAppImageConfigMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateAppImageConfigOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateAppImageConfigInput struct {
// The name of the AppImageConfig. Must be unique to your account.
//
// This member is required.
AppImageConfigName *string
// The KernelGatewayImageConfig.
KernelGatewayImageConfig *types.KernelGatewayImageConfig
// A list of tags to apply to the AppImageConfig.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateAppImageConfigOutput struct {
// The Amazon Resource Name (ARN) of the AppImageConfig.
AppImageConfigArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateAppImageConfigMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateAppImageConfig{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateAppImageConfig{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateAppImageConfigValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateAppImageConfig(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreateAppImageConfig(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateAppImageConfig",
}
}

143
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateArtifact.go generated vendored Normal file
View File

@@ -0,0 +1,143 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates an artifact. An artifact is a lineage tracking entity that represents a
// URI addressable object or data. Some examples are the S3 URI of a dataset and
// the ECR registry path of an image. For more information, see Amazon SageMaker ML
// Lineage Tracking
// (https://docs.aws.amazon.com/sagemaker/latest/dg/lineage-tracking.html).
func (c *Client) CreateArtifact(ctx context.Context, params *CreateArtifactInput, optFns ...func(*Options)) (*CreateArtifactOutput, error) {
if params == nil {
params = &CreateArtifactInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateArtifact", params, optFns, c.addOperationCreateArtifactMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateArtifactOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateArtifactInput struct {
// The artifact type.
//
// This member is required.
ArtifactType *string
// The ID, ID type, and URI of the source.
//
// This member is required.
Source *types.ArtifactSource
// The name of the artifact. Must be unique to your account in an Amazon Web
// Services Region.
ArtifactName *string
// Metadata properties of the tracking entity, trial, or trial component.
MetadataProperties *types.MetadataProperties
// A list of properties to add to the artifact.
Properties map[string]string
// A list of tags to apply to the artifact.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateArtifactOutput struct {
// The Amazon Resource Name (ARN) of the artifact.
ArtifactArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateArtifactMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateArtifact{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateArtifact{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateArtifactValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateArtifact(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreateArtifact(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateArtifact",
}
}

172
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateAutoMLJob.go generated vendored Normal file
View File

@@ -0,0 +1,172 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates an Autopilot job. Find the best-performing model after you run an
// Autopilot job by calling . For information about how to use Autopilot, see
// Automate Model Development with Amazon SageMaker Autopilot
// (https://docs.aws.amazon.com/sagemaker/latest/dg/autopilot-automate-model-development.html).
func (c *Client) CreateAutoMLJob(ctx context.Context, params *CreateAutoMLJobInput, optFns ...func(*Options)) (*CreateAutoMLJobOutput, error) {
if params == nil {
params = &CreateAutoMLJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateAutoMLJob", params, optFns, c.addOperationCreateAutoMLJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateAutoMLJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateAutoMLJobInput struct {
// Identifies an Autopilot job. The name must be unique to your account and is
// case-insensitive.
//
// This member is required.
AutoMLJobName *string
// An array of channel objects that describes the input data and its location. Each
// channel is a named input source. Similar to InputDataConfig supported by .
// Format(s) supported: CSV. Minimum of 500 rows.
//
// This member is required.
InputDataConfig []types.AutoMLChannel
// Provides information about encryption and the Amazon S3 output path needed to
// store artifacts from an AutoML job. Format(s) supported: CSV.
//
// This member is required.
OutputDataConfig *types.AutoMLOutputDataConfig
// The ARN of the role that is used to access the data.
//
// This member is required.
RoleArn *string
// Contains CompletionCriteria and SecurityConfig settings for the AutoML job.
AutoMLJobConfig *types.AutoMLJobConfig
// Defines the objective metric used to measure the predictive quality of an AutoML
// job. You provide an AutoMLJobObjective$MetricName and Autopilot infers whether
// to minimize or maximize it.
AutoMLJobObjective *types.AutoMLJobObjective
// Generates possible candidates without training the models. A candidate is a
// combination of data preprocessors, algorithms, and algorithm parameter settings.
GenerateCandidateDefinitionsOnly bool
// Specifies how to generate the endpoint name for an automatic one-click Autopilot
// model deployment.
ModelDeployConfig *types.ModelDeployConfig
// Defines the type of supervised learning available for the candidates. Options
// include: BinaryClassification, MulticlassClassification, and Regression. For
// more information, see Amazon SageMaker Autopilot problem types and algorithm
// support
// (https://docs.aws.amazon.com/sagemaker/latest/dg/autopilot-automate-model-development-problem-types.html).
ProblemType types.ProblemType
// Each tag consists of a key and an optional value. Tag keys must be unique per
// resource.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateAutoMLJobOutput struct {
// The unique ARN assigned to the AutoML job when it is created.
//
// This member is required.
AutoMLJobArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateAutoMLJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateAutoMLJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateAutoMLJob{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateAutoMLJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateAutoMLJob(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreateAutoMLJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateAutoMLJob",
}
}

144
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateCodeRepository.go generated vendored Normal file
View File

@@ -0,0 +1,144 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a Git repository as a resource in your Amazon SageMaker account. You can
// associate the repository with notebook instances so that you can use Git source
// control for the notebooks you create. The Git repository is a resource in your
// Amazon SageMaker account, so it can be associated with more than one notebook
// instance, and it persists independently from the lifecycle of any notebook
// instances it is associated with. The repository can be hosted either in Amazon
// Web Services CodeCommit
// (https://docs.aws.amazon.com/codecommit/latest/userguide/welcome.html) or in any
// other Git repository.
func (c *Client) CreateCodeRepository(ctx context.Context, params *CreateCodeRepositoryInput, optFns ...func(*Options)) (*CreateCodeRepositoryOutput, error) {
if params == nil {
params = &CreateCodeRepositoryInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateCodeRepository", params, optFns, c.addOperationCreateCodeRepositoryMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateCodeRepositoryOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateCodeRepositoryInput struct {
// The name of the Git repository. The name must have 1 to 63 characters. Valid
// characters are a-z, A-Z, 0-9, and - (hyphen).
//
// This member is required.
CodeRepositoryName *string
// Specifies details about the repository, including the URL where the repository
// is located, the default branch, and credentials to use to access the repository.
//
// This member is required.
GitConfig *types.GitConfig
// An array of key-value pairs. You can use tags to categorize your Amazon Web
// Services resources in different ways, for example, by purpose, owner, or
// environment. For more information, see Tagging Amazon Web Services Resources
// (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html).
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateCodeRepositoryOutput struct {
// The Amazon Resource Name (ARN) of the new repository.
//
// This member is required.
CodeRepositoryArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateCodeRepositoryMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateCodeRepository{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateCodeRepository{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateCodeRepositoryValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateCodeRepository(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreateCodeRepository(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateCodeRepository",
}
}

207
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateCompilationJob.go generated vendored Normal file
View File

@@ -0,0 +1,207 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Starts a model compilation job. After the model has been compiled, Amazon
// SageMaker saves the resulting model artifacts to an Amazon Simple Storage
// Service (Amazon S3) bucket that you specify. If you choose to host your model
// using Amazon SageMaker hosting services, you can use the resulting model
// artifacts as part of the model. You can also use the artifacts with Amazon Web
// Services IoT Greengrass. In that case, deploy them as an ML resource. In the
// request body, you provide the following:
//
// * A name for the compilation job
//
// *
// Information about the input model artifacts
//
// * The output location for the
// compiled model and the device (target) that the model runs on
//
// * The Amazon
// Resource Name (ARN) of the IAM role that Amazon SageMaker assumes to perform the
// model compilation job.
//
// You can also provide a Tag to track the model
// compilation job's resource use and costs. The response body contains the
// CompilationJobArn for the compiled job. To stop a model compilation job, use
// StopCompilationJob. To get information about a particular model compilation job,
// use DescribeCompilationJob. To get information about multiple model compilation
// jobs, use ListCompilationJobs.
func (c *Client) CreateCompilationJob(ctx context.Context, params *CreateCompilationJobInput, optFns ...func(*Options)) (*CreateCompilationJobOutput, error) {
if params == nil {
params = &CreateCompilationJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateCompilationJob", params, optFns, c.addOperationCreateCompilationJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateCompilationJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateCompilationJobInput struct {
// A name for the model compilation job. The name must be unique within the Amazon
// Web Services Region and within your Amazon Web Services account.
//
// This member is required.
CompilationJobName *string
// Provides information about the location of input model artifacts, the name and
// shape of the expected data inputs, and the framework in which the model was
// trained.
//
// This member is required.
InputConfig *types.InputConfig
// Provides information about the output location for the compiled model and the
// target device the model runs on.
//
// This member is required.
OutputConfig *types.OutputConfig
// The Amazon Resource Name (ARN) of an IAM role that enables Amazon SageMaker to
// perform tasks on your behalf. During model compilation, Amazon SageMaker needs
// your permission to:
//
// * Read input data from an S3 bucket
//
// * Write model
// artifacts to an S3 bucket
//
// * Write logs to Amazon CloudWatch Logs
//
// * Publish
// metrics to Amazon CloudWatch
//
// You grant permissions for all of these tasks to an
// IAM role. To pass this role to Amazon SageMaker, the caller of this API must
// have the iam:PassRole permission. For more information, see Amazon SageMaker
// Roles. (https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html)
//
// This member is required.
RoleArn *string
// Specifies a limit to how long a model compilation job can run. When the job
// reaches the time limit, Amazon SageMaker ends the compilation job. Use this API
// to cap model training costs.
//
// This member is required.
StoppingCondition *types.StoppingCondition
// An array of key-value pairs. You can use tags to categorize your Amazon Web
// Services resources in different ways, for example, by purpose, owner, or
// environment. For more information, see Tagging Amazon Web Services Resources
// (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html).
Tags []types.Tag
// A VpcConfig object that specifies the VPC that you want your compilation job to
// connect to. Control access to your models by configuring the VPC. For more
// information, see Protect Compilation Jobs by Using an Amazon Virtual Private
// Cloud (https://docs.aws.amazon.com/sagemaker/latest/dg/neo-vpc.html).
VpcConfig *types.NeoVpcConfig
noSmithyDocumentSerde
}
type CreateCompilationJobOutput struct {
// If the action is successful, the service sends back an HTTP 200 response. Amazon
// SageMaker returns the following data in JSON format:
//
// * CompilationJobArn: The
// Amazon Resource Name (ARN) of the compiled job.
//
// This member is required.
CompilationJobArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateCompilationJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateCompilationJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateCompilationJob{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateCompilationJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateCompilationJob(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreateCompilationJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateCompilationJob",
}
}

145
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateContext.go generated vendored Normal file
View File

@@ -0,0 +1,145 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a context. A context is a lineage tracking entity that represents a
// logical grouping of other tracking or experiment entities. Some examples are an
// endpoint and a model package. For more information, see Amazon SageMaker ML
// Lineage Tracking
// (https://docs.aws.amazon.com/sagemaker/latest/dg/lineage-tracking.html).
func (c *Client) CreateContext(ctx context.Context, params *CreateContextInput, optFns ...func(*Options)) (*CreateContextOutput, error) {
if params == nil {
params = &CreateContextInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateContext", params, optFns, c.addOperationCreateContextMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateContextOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateContextInput struct {
// The name of the context. Must be unique to your account in an Amazon Web
// Services Region.
//
// This member is required.
ContextName *string
// The context type.
//
// This member is required.
ContextType *string
// The source type, ID, and URI.
//
// This member is required.
Source *types.ContextSource
// The description of the context.
Description *string
// A list of properties to add to the context.
Properties map[string]string
// A list of tags to apply to the context.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateContextOutput struct {
// The Amazon Resource Name (ARN) of the context.
ContextArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateContextMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateContext{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateContext{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateContextValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateContext(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreateContext(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateContext",
}
}

167
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateDataQualityJobDefinition.go generated vendored Normal file
View File

@@ -0,0 +1,167 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a definition for a job that monitors data quality and drift. For
// information about model monitor, see Amazon SageMaker Model Monitor
// (https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor.html).
func (c *Client) CreateDataQualityJobDefinition(ctx context.Context, params *CreateDataQualityJobDefinitionInput, optFns ...func(*Options)) (*CreateDataQualityJobDefinitionOutput, error) {
if params == nil {
params = &CreateDataQualityJobDefinitionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateDataQualityJobDefinition", params, optFns, c.addOperationCreateDataQualityJobDefinitionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateDataQualityJobDefinitionOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateDataQualityJobDefinitionInput struct {
// Specifies the container that runs the monitoring job.
//
// This member is required.
DataQualityAppSpecification *types.DataQualityAppSpecification
// A list of inputs for the monitoring job. Currently endpoints are supported as
// monitoring inputs.
//
// This member is required.
DataQualityJobInput *types.DataQualityJobInput
// The output configuration for monitoring jobs.
//
// This member is required.
DataQualityJobOutputConfig *types.MonitoringOutputConfig
// The name for the monitoring job definition.
//
// This member is required.
JobDefinitionName *string
// Identifies the resources to deploy for a monitoring job.
//
// This member is required.
JobResources *types.MonitoringResources
// The Amazon Resource Name (ARN) of an IAM role that Amazon SageMaker can assume
// to perform tasks on your behalf.
//
// This member is required.
RoleArn *string
// Configures the constraints and baselines for the monitoring job.
DataQualityBaselineConfig *types.DataQualityBaselineConfig
// Specifies networking configuration for the monitoring job.
NetworkConfig *types.MonitoringNetworkConfig
// A time limit for how long the monitoring job is allowed to run before stopping.
StoppingCondition *types.MonitoringStoppingCondition
// (Optional) An array of key-value pairs. For more information, see Using Cost
// Allocation Tags
// (https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html#allocation-whatURL)
// in the Amazon Web Services Billing and Cost Management User Guide.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateDataQualityJobDefinitionOutput struct {
// The Amazon Resource Name (ARN) of the job definition.
//
// This member is required.
JobDefinitionArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateDataQualityJobDefinitionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateDataQualityJobDefinition{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateDataQualityJobDefinition{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateDataQualityJobDefinitionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateDataQualityJobDefinition(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreateDataQualityJobDefinition(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateDataQualityJobDefinition",
}
}

138
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateDeviceFleet.go generated vendored Normal file
View File

@@ -0,0 +1,138 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a device fleet.
func (c *Client) CreateDeviceFleet(ctx context.Context, params *CreateDeviceFleetInput, optFns ...func(*Options)) (*CreateDeviceFleetOutput, error) {
if params == nil {
params = &CreateDeviceFleetInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateDeviceFleet", params, optFns, c.addOperationCreateDeviceFleetMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateDeviceFleetOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateDeviceFleetInput struct {
// The name of the fleet that the device belongs to.
//
// This member is required.
DeviceFleetName *string
// The output configuration for storing sample data collected by the fleet.
//
// This member is required.
OutputConfig *types.EdgeOutputConfig
// A description of the fleet.
Description *string
// Whether to create an Amazon Web Services IoT Role Alias during device fleet
// creation. The name of the role alias generated will match this pattern:
// "SageMakerEdge-{DeviceFleetName}". For example, if your device fleet is called
// "demo-fleet", the name of the role alias will be "SageMakerEdge-demo-fleet".
EnableIotRoleAlias *bool
// The Amazon Resource Name (ARN) that has access to Amazon Web Services Internet
// of Things (IoT).
RoleArn *string
// Creates tags for the specified fleet.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateDeviceFleetOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateDeviceFleetMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateDeviceFleet{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateDeviceFleet{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateDeviceFleetValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateDeviceFleet(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreateDeviceFleet(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateDeviceFleet",
}
}

210
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateDomain.go generated vendored Normal file
View File

@@ -0,0 +1,210 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a Domain used by Amazon SageMaker Studio. A domain consists of an
// associated Amazon Elastic File System (EFS) volume, a list of authorized users,
// and a variety of security, application, policy, and Amazon Virtual Private Cloud
// (VPC) configurations. An Amazon Web Services account is limited to one domain
// per region. Users within a domain can share notebook files and other artifacts
// with each other. EFS storage When a domain is created, an EFS volume is created
// for use by all of the users within the domain. Each user receives a private home
// directory within the EFS volume for notebooks, Git repositories, and data files.
// SageMaker uses the Amazon Web Services Key Management Service (Amazon Web
// Services KMS) to encrypt the EFS volume attached to the domain with an Amazon
// Web Services managed key by default. For more control, you can specify a
// customer managed key. For more information, see Protect Data at Rest Using
// Encryption
// (https://docs.aws.amazon.com/sagemaker/latest/dg/encryption-at-rest.html). VPC
// configuration All SageMaker Studio traffic between the domain and the EFS volume
// is through the specified VPC and subnets. For other Studio traffic, you can
// specify the AppNetworkAccessType parameter. AppNetworkAccessType corresponds to
// the network access type that you choose when you onboard to Studio. The
// following options are available:
//
// * PublicInternetOnly - Non-EFS traffic goes
// through a VPC managed by Amazon SageMaker, which allows internet access. This is
// the default value.
//
// * VpcOnly - All Studio traffic is through the specified VPC
// and subnets. Internet access is disabled by default. To allow internet access,
// you must specify a NAT gateway. When internet access is disabled, you won't be
// able to run a Studio notebook or to train or host models unless your VPC has an
// interface endpoint to the SageMaker API and runtime or a NAT gateway and your
// security groups allow outbound connections.
//
// NFS traffic over TCP on port 2049
// needs to be allowed in both inbound and outbound rules in order to launch a
// SageMaker Studio app successfully. For more information, see Connect SageMaker
// Studio Notebooks to Resources in a VPC
// (https://docs.aws.amazon.com/sagemaker/latest/dg/studio-notebooks-and-internet-access.html).
func (c *Client) CreateDomain(ctx context.Context, params *CreateDomainInput, optFns ...func(*Options)) (*CreateDomainOutput, error) {
if params == nil {
params = &CreateDomainInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateDomain", params, optFns, c.addOperationCreateDomainMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateDomainOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateDomainInput struct {
// The mode of authentication that members use to access the domain.
//
// This member is required.
AuthMode types.AuthMode
// The default settings to use to create a user profile when UserSettings isn't
// specified in the call to the CreateUserProfile API. SecurityGroups is aggregated
// when specified in both calls. For all other settings in UserSettings, the values
// specified in CreateUserProfile take precedence over those specified in
// CreateDomain.
//
// This member is required.
DefaultUserSettings *types.UserSettings
// A name for the domain.
//
// This member is required.
DomainName *string
// The VPC subnets that Studio uses for communication.
//
// This member is required.
SubnetIds []string
// The ID of the Amazon Virtual Private Cloud (VPC) that Studio uses for
// communication.
//
// This member is required.
VpcId *string
// Specifies the VPC used for non-EFS traffic. The default value is
// PublicInternetOnly.
//
// * PublicInternetOnly - Non-EFS traffic is through a VPC
// managed by Amazon SageMaker, which allows direct internet access
//
// * VpcOnly -
// All Studio traffic is through the specified VPC and subnets
AppNetworkAccessType types.AppNetworkAccessType
// This member is deprecated and replaced with KmsKeyId.
//
// Deprecated: This property is deprecated, use KmsKeyId instead.
HomeEfsFileSystemKmsKeyId *string
// SageMaker uses Amazon Web Services KMS to encrypt the EFS volume attached to the
// domain with an Amazon Web Services managed key by default. For more control,
// specify a customer managed key.
KmsKeyId *string
// Tags to associated with the Domain. Each tag consists of a key and an optional
// value. Tag keys must be unique per resource. Tags are searchable using the
// Search API. Tags that you specify for the Domain are also added to all Apps that
// the Domain launches.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateDomainOutput struct {
// The Amazon Resource Name (ARN) of the created domain.
DomainArn *string
// The URL to the created domain.
Url *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateDomainMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateDomain{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateDomain{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateDomainValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateDomain(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreateDomain(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateDomain",
}
}

154
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateEdgePackagingJob.go generated vendored Normal file
View File

@@ -0,0 +1,154 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Starts a SageMaker Edge Manager model packaging job. Edge Manager will use the
// model artifacts from the Amazon Simple Storage Service bucket that you specify.
// After the model has been packaged, Amazon SageMaker saves the resulting
// artifacts to an S3 bucket that you specify.
func (c *Client) CreateEdgePackagingJob(ctx context.Context, params *CreateEdgePackagingJobInput, optFns ...func(*Options)) (*CreateEdgePackagingJobOutput, error) {
if params == nil {
params = &CreateEdgePackagingJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateEdgePackagingJob", params, optFns, c.addOperationCreateEdgePackagingJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateEdgePackagingJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateEdgePackagingJobInput struct {
// The name of the SageMaker Neo compilation job that will be used to locate model
// artifacts for packaging.
//
// This member is required.
CompilationJobName *string
// The name of the edge packaging job.
//
// This member is required.
EdgePackagingJobName *string
// The name of the model.
//
// This member is required.
ModelName *string
// The version of the model.
//
// This member is required.
ModelVersion *string
// Provides information about the output location for the packaged model.
//
// This member is required.
OutputConfig *types.EdgeOutputConfig
// The Amazon Resource Name (ARN) of an IAM role that enables Amazon SageMaker to
// download and upload the model, and to contact SageMaker Neo.
//
// This member is required.
RoleArn *string
// The Amazon Web Services KMS key to use when encrypting the EBS volume the edge
// packaging job runs on.
ResourceKey *string
// Creates tags for the packaging job.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateEdgePackagingJobOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateEdgePackagingJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateEdgePackagingJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateEdgePackagingJob{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateEdgePackagingJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateEdgePackagingJob(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreateEdgePackagingJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateEdgePackagingJob",
}
}

190
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateEndpoint.go generated vendored Normal file
View File

@@ -0,0 +1,190 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates an endpoint using the endpoint configuration specified in the request.
// Amazon SageMaker uses the endpoint to provision resources and deploy models. You
// create the endpoint configuration with the CreateEndpointConfig API. Use this
// API to deploy models using Amazon SageMaker hosting services. For an example
// that calls this method when deploying a model to Amazon SageMaker hosting
// services, see the Create Endpoint example notebook.
// (https://github.com/aws/amazon-sagemaker-examples/blob/master/sagemaker-fundamentals/create-endpoint/create_endpoint.ipynb)
// You must not delete an EndpointConfig that is in use by an endpoint that is live
// or while the UpdateEndpoint or CreateEndpoint operations are being performed on
// the endpoint. To update an endpoint, you must create a new EndpointConfig. The
// endpoint name must be unique within an Amazon Web Services Region in your Amazon
// Web Services account. When it receives the request, Amazon SageMaker creates the
// endpoint, launches the resources (ML compute instances), and deploys the
// model(s) on them. When you call CreateEndpoint, a load call is made to DynamoDB
// to verify that your endpoint configuration exists. When you read data from a
// DynamoDB table supporting Eventually Consistent Reads
// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.ReadConsistency.html),
// the response might not reflect the results of a recently completed write
// operation. The response might include some stale data. If the dependent entities
// are not yet in DynamoDB, this causes a validation error. If you repeat your read
// request after a short time, the response should return the latest data. So retry
// logic is recommended to handle these possible issues. We also recommend that
// customers call DescribeEndpointConfig before calling CreateEndpoint to minimize
// the potential impact of a DynamoDB eventually consistent read. When Amazon
// SageMaker receives the request, it sets the endpoint status to Creating. After
// it creates the endpoint, it sets the status to InService. Amazon SageMaker can
// then process incoming requests for inferences. To check the status of an
// endpoint, use the DescribeEndpoint API. If any of the models hosted at this
// endpoint get model data from an Amazon S3 location, Amazon SageMaker uses Amazon
// Web Services Security Token Service to download model artifacts from the S3 path
// you provided. Amazon Web Services STS is activated in your IAM user account by
// default. If you previously deactivated Amazon Web Services STS for a region, you
// need to reactivate Amazon Web Services STS for that region. For more
// information, see Activating and Deactivating Amazon Web Services STS in an
// Amazon Web Services Region
// (https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_enable-regions.html)
// in the Amazon Web Services Identity and Access Management User Guide. To add the
// IAM role policies for using this API operation, go to the IAM console
// (https://console.aws.amazon.com/iam/), and choose Roles in the left navigation
// pane. Search the IAM role that you want to grant access to use the
// CreateEndpoint and CreateEndpointConfig API operations, add the following
// policies to the role.
//
// * Option 1: For a full Amazon SageMaker access, search
// and attach the AmazonSageMakerFullAccess policy.
//
// * Option 2: For granting a
// limited access to an IAM role, paste the following Action elements manually into
// the JSON file of the IAM role: "Action": ["sagemaker:CreateEndpoint",
// "sagemaker:CreateEndpointConfig"]"Resource":
// ["arn:aws:sagemaker:region:account-id:endpoint/endpointName""arn:aws:sagemaker:region:account-id:endpoint-config/endpointConfigName"]
// For more information, see Amazon SageMaker API Permissions: Actions,
// Permissions, and Resources Reference
// (https://docs.aws.amazon.com/sagemaker/latest/dg/api-permissions-reference.html).
func (c *Client) CreateEndpoint(ctx context.Context, params *CreateEndpointInput, optFns ...func(*Options)) (*CreateEndpointOutput, error) {
if params == nil {
params = &CreateEndpointInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateEndpoint", params, optFns, c.addOperationCreateEndpointMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateEndpointOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateEndpointInput struct {
// The name of an endpoint configuration. For more information, see
// CreateEndpointConfig.
//
// This member is required.
EndpointConfigName *string
// The name of the endpoint.The name must be unique within an Amazon Web Services
// Region in your Amazon Web Services account. The name is case-insensitive in
// CreateEndpoint, but the case is preserved and must be matched in .
//
// This member is required.
EndpointName *string
// An array of key-value pairs. You can use tags to categorize your Amazon Web
// Services resources in different ways, for example, by purpose, owner, or
// environment. For more information, see Tagging Amazon Web Services Resources
// (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html).
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateEndpointOutput struct {
// The Amazon Resource Name (ARN) of the endpoint.
//
// This member is required.
EndpointArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateEndpointMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateEndpoint{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateEndpoint{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateEndpointValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateEndpoint(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreateEndpoint(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateEndpoint",
}
}

204
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateEndpointConfig.go generated vendored Normal file
View File

@@ -0,0 +1,204 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates an endpoint configuration that Amazon SageMaker hosting services uses to
// deploy models. In the configuration, you identify one or more models, created
// using the CreateModel API, to deploy and the resources that you want Amazon
// SageMaker to provision. Then you call the CreateEndpoint API. Use this API if
// you want to use Amazon SageMaker hosting services to deploy models into
// production. In the request, you define a ProductionVariant, for each model that
// you want to deploy. Each ProductionVariant parameter also describes the
// resources that you want Amazon SageMaker to provision. This includes the number
// and type of ML compute instances to deploy. If you are hosting multiple models,
// you also assign a VariantWeight to specify how much traffic you want to allocate
// to each model. For example, suppose that you want to host two models, A and B,
// and you assign traffic weight 2 for model A and 1 for model B. Amazon SageMaker
// distributes two-thirds of the traffic to Model A, and one-third to model B. When
// you call CreateEndpoint, a load call is made to DynamoDB to verify that your
// endpoint configuration exists. When you read data from a DynamoDB table
// supporting Eventually Consistent Reads
// (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.ReadConsistency.html),
// the response might not reflect the results of a recently completed write
// operation. The response might include some stale data. If the dependent entities
// are not yet in DynamoDB, this causes a validation error. If you repeat your read
// request after a short time, the response should return the latest data. So retry
// logic is recommended to handle these possible issues. We also recommend that
// customers call DescribeEndpointConfig before calling CreateEndpoint to minimize
// the potential impact of a DynamoDB eventually consistent read.
func (c *Client) CreateEndpointConfig(ctx context.Context, params *CreateEndpointConfigInput, optFns ...func(*Options)) (*CreateEndpointConfigOutput, error) {
if params == nil {
params = &CreateEndpointConfigInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateEndpointConfig", params, optFns, c.addOperationCreateEndpointConfigMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateEndpointConfigOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateEndpointConfigInput struct {
// The name of the endpoint configuration. You specify this name in a
// CreateEndpoint request.
//
// This member is required.
EndpointConfigName *string
// An list of ProductionVariant objects, one for each model that you want to host
// at this endpoint.
//
// This member is required.
ProductionVariants []types.ProductionVariant
// Specifies configuration for how an endpoint performs asynchronous inference.
// This is a required field in order for your Endpoint to be invoked using
// InvokeEndpointAsync
// (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html).
AsyncInferenceConfig *types.AsyncInferenceConfig
//
DataCaptureConfig *types.DataCaptureConfig
// The Amazon Resource Name (ARN) of a Amazon Web Services Key Management Service
// key that Amazon SageMaker uses to encrypt data on the storage volume attached to
// the ML compute instance that hosts the endpoint. The KmsKeyId can be any of the
// following formats:
//
// * Key ID: 1234abcd-12ab-34cd-56ef-1234567890ab
//
// * Key ARN:
// arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab
//
// *
// Alias name: alias/ExampleAlias
//
// * Alias name ARN:
// arn:aws:kms:us-west-2:111122223333:alias/ExampleAlias
//
// The KMS key policy must
// grant permission to the IAM role that you specify in your CreateEndpoint,
// UpdateEndpoint requests. For more information, refer to the Amazon Web Services
// Key Management Service section Using Key Policies in Amazon Web Services KMS
// (https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html)
// Certain Nitro-based instances include local storage, dependent on the instance
// type. Local storage volumes are encrypted using a hardware module on the
// instance. You can't request a KmsKeyId when using an instance type with local
// storage. If any of the models that you specify in the ProductionVariants
// parameter use nitro-based instances with local storage, do not specify a value
// for the KmsKeyId parameter. If you specify a value for KmsKeyId when using any
// nitro-based instances with local storage, the call to CreateEndpointConfig
// fails. For a list of instance types that support local instance storage, see
// Instance Store Volumes
// (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/InstanceStorage.html#instance-store-volumes).
// For more information about local instance storage encryption, see SSD Instance
// Store Volumes
// (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ssd-instance-store.html).
KmsKeyId *string
// An array of key-value pairs. You can use tags to categorize your Amazon Web
// Services resources in different ways, for example, by purpose, owner, or
// environment. For more information, see Tagging Amazon Web Services Resources
// (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html).
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateEndpointConfigOutput struct {
// The Amazon Resource Name (ARN) of the endpoint configuration.
//
// This member is required.
EndpointConfigArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateEndpointConfigMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateEndpointConfig{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateEndpointConfig{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateEndpointConfigValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateEndpointConfig(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreateEndpointConfig(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateEndpointConfig",
}
}

149
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateExperiment.go generated vendored Normal file
View File

@@ -0,0 +1,149 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates an SageMaker experiment. An experiment is a collection of trials that
// are observed, compared and evaluated as a group. A trial is a set of steps,
// called trial components, that produce a machine learning model. The goal of an
// experiment is to determine the components that produce the best model. Multiple
// trials are performed, each one isolating and measuring the impact of a change to
// one or more inputs, while keeping the remaining inputs constant. When you use
// SageMaker Studio or the SageMaker Python SDK, all experiments, trials, and trial
// components are automatically tracked, logged, and indexed. When you use the
// Amazon Web Services SDK for Python (Boto), you must use the logging APIs
// provided by the SDK. You can add tags to experiments, trials, trial components
// and then use the Search API to search for the tags. To add a description to an
// experiment, specify the optional Description parameter. To add a description
// later, or to change the description, call the UpdateExperiment API. To get a
// list of all your experiments, call the ListExperiments API. To view an
// experiment's properties, call the DescribeExperiment API. To get a list of all
// the trials associated with an experiment, call the ListTrials API. To create a
// trial call the CreateTrial API.
func (c *Client) CreateExperiment(ctx context.Context, params *CreateExperimentInput, optFns ...func(*Options)) (*CreateExperimentOutput, error) {
if params == nil {
params = &CreateExperimentInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateExperiment", params, optFns, c.addOperationCreateExperimentMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateExperimentOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateExperimentInput struct {
// The name of the experiment. The name must be unique in your Amazon Web Services
// account and is not case-sensitive.
//
// This member is required.
ExperimentName *string
// The description of the experiment.
Description *string
// The name of the experiment as displayed. The name doesn't need to be unique. If
// you don't specify DisplayName, the value in ExperimentName is displayed.
DisplayName *string
// A list of tags to associate with the experiment. You can use Search API to
// search on the tags.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateExperimentOutput struct {
// The Amazon Resource Name (ARN) of the experiment.
ExperimentArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateExperimentMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateExperiment{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateExperiment{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateExperimentValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateExperiment(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreateExperiment(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateExperiment",
}
}

212
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateFeatureGroup.go generated vendored Normal file
View File

@@ -0,0 +1,212 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Create a new FeatureGroup. A FeatureGroup is a group of Features defined in the
// FeatureStore to describe a Record. The FeatureGroup defines the schema and
// features contained in the FeatureGroup. A FeatureGroup definition is composed of
// a list of Features, a RecordIdentifierFeatureName, an EventTimeFeatureName and
// configurations for its OnlineStore and OfflineStore. Check Amazon Web Services
// service quotas
// (https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html) to see
// the FeatureGroups quota for your Amazon Web Services account. You must include
// at least one of OnlineStoreConfig and OfflineStoreConfig to create a
// FeatureGroup.
func (c *Client) CreateFeatureGroup(ctx context.Context, params *CreateFeatureGroupInput, optFns ...func(*Options)) (*CreateFeatureGroupOutput, error) {
if params == nil {
params = &CreateFeatureGroupInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateFeatureGroup", params, optFns, c.addOperationCreateFeatureGroupMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateFeatureGroupOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateFeatureGroupInput struct {
// The name of the feature that stores the EventTime of a Record in a FeatureGroup.
// An EventTime is a point in time when a new event occurs that corresponds to the
// creation or update of a Record in a FeatureGroup. All Records in the
// FeatureGroup must have a corresponding EventTime. An EventTime can be a String
// or Fractional.
//
// * Fractional: EventTime feature values must be a Unix timestamp
// in seconds.
//
// * String: EventTime feature values must be an ISO-8601 string in
// the format. The following formats are supported yyyy-MM-dd'T'HH:mm:ssZ and
// yyyy-MM-dd'T'HH:mm:ss.SSSZ where yyyy, MM, and dd represent the year, month, and
// day respectively and HH, mm, ss, and if applicable, SSS represent the hour,
// month, second and milliseconds respsectively. 'T' and Z are constants.
//
// This member is required.
EventTimeFeatureName *string
// A list of Feature names and types. Name and Type is compulsory per Feature.
// Valid feature FeatureTypes are Integral, Fractional and String. FeatureNames
// cannot be any of the following: is_deleted, write_time, api_invocation_time You
// can create up to 2,500 FeatureDefinitions per FeatureGroup.
//
// This member is required.
FeatureDefinitions []types.FeatureDefinition
// The name of the FeatureGroup. The name must be unique within an Amazon Web
// Services Region in an Amazon Web Services account. The name:
//
// * Must start and
// end with an alphanumeric character.
//
// * Can only contain alphanumeric character
// and hyphens. Spaces are not allowed.
//
// This member is required.
FeatureGroupName *string
// The name of the Feature whose value uniquely identifies a Record defined in the
// FeatureStore. Only the latest record per identifier value will be stored in the
// OnlineStore. RecordIdentifierFeatureName must be one of feature definitions'
// names. You use the RecordIdentifierFeatureName to access data in a FeatureStore.
// This name:
//
// * Must start and end with an alphanumeric character.
//
// * Can only
// contains alphanumeric characters, hyphens, underscores. Spaces are not allowed.
//
// This member is required.
RecordIdentifierFeatureName *string
// A free-form description of a FeatureGroup.
Description *string
// Use this to configure an OfflineFeatureStore. This parameter allows you to
// specify:
//
// * The Amazon Simple Storage Service (Amazon S3) location of an
// OfflineStore.
//
// * A configuration for an Amazon Web Services Glue or Amazon Web
// Services Hive data cataolgue.
//
// * An KMS encryption key to encrypt the Amazon S3
// location used for OfflineStore.
//
// To learn more about this parameter, see
// OfflineStoreConfig.
OfflineStoreConfig *types.OfflineStoreConfig
// You can turn the OnlineStore on or off by specifying True for the
// EnableOnlineStore flag in OnlineStoreConfig; the default value is False. You can
// also include an Amazon Web Services KMS key ID (KMSKeyId) for at-rest encryption
// of the OnlineStore.
OnlineStoreConfig *types.OnlineStoreConfig
// The Amazon Resource Name (ARN) of the IAM execution role used to persist data
// into the OfflineStore if an OfflineStoreConfig is provided.
RoleArn *string
// Tags used to identify Features in each FeatureGroup.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateFeatureGroupOutput struct {
// The Amazon Resource Name (ARN) of the FeatureGroup. This is a unique identifier
// for the feature group.
//
// This member is required.
FeatureGroupArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateFeatureGroupMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateFeatureGroup{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateFeatureGroup{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateFeatureGroupValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateFeatureGroup(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreateFeatureGroup(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateFeatureGroup",
}
}

154
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateFlowDefinition.go generated vendored Normal file
View File

@@ -0,0 +1,154 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a flow definition.
func (c *Client) CreateFlowDefinition(ctx context.Context, params *CreateFlowDefinitionInput, optFns ...func(*Options)) (*CreateFlowDefinitionOutput, error) {
if params == nil {
params = &CreateFlowDefinitionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateFlowDefinition", params, optFns, c.addOperationCreateFlowDefinitionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateFlowDefinitionOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateFlowDefinitionInput struct {
// The name of your flow definition.
//
// This member is required.
FlowDefinitionName *string
// An object containing information about the tasks the human reviewers will
// perform.
//
// This member is required.
HumanLoopConfig *types.HumanLoopConfig
// An object containing information about where the human review results will be
// uploaded.
//
// This member is required.
OutputConfig *types.FlowDefinitionOutputConfig
// The Amazon Resource Name (ARN) of the role needed to call other services on your
// behalf. For example,
// arn:aws:iam::1234567890:role/service-role/AmazonSageMaker-ExecutionRole-20180111T151298.
//
// This member is required.
RoleArn *string
// An object containing information about the events that trigger a human workflow.
HumanLoopActivationConfig *types.HumanLoopActivationConfig
// Container for configuring the source of human task requests. Use to specify if
// Amazon Rekognition or Amazon Textract is used as an integration source.
HumanLoopRequestSource *types.HumanLoopRequestSource
// An array of key-value pairs that contain metadata to help you categorize and
// organize a flow definition. Each tag consists of a key and a value, both of
// which you define.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateFlowDefinitionOutput struct {
// The Amazon Resource Name (ARN) of the flow definition you create.
//
// This member is required.
FlowDefinitionArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateFlowDefinitionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateFlowDefinition{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateFlowDefinition{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateFlowDefinitionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateFlowDefinition(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreateFlowDefinition(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateFlowDefinition",
}
}

136
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateHumanTaskUi.go generated vendored Normal file
View File

@@ -0,0 +1,136 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Defines the settings you will use for the human review workflow user interface.
// Reviewers will see a three-panel interface with an instruction area, the item to
// review, and an input area.
func (c *Client) CreateHumanTaskUi(ctx context.Context, params *CreateHumanTaskUiInput, optFns ...func(*Options)) (*CreateHumanTaskUiOutput, error) {
if params == nil {
params = &CreateHumanTaskUiInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateHumanTaskUi", params, optFns, c.addOperationCreateHumanTaskUiMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateHumanTaskUiOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateHumanTaskUiInput struct {
// The name of the user interface you are creating.
//
// This member is required.
HumanTaskUiName *string
// The Liquid template for the worker user interface.
//
// This member is required.
UiTemplate *types.UiTemplate
// An array of key-value pairs that contain metadata to help you categorize and
// organize a human review workflow user interface. Each tag consists of a key and
// a value, both of which you define.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateHumanTaskUiOutput struct {
// The Amazon Resource Name (ARN) of the human review workflow user interface you
// create.
//
// This member is required.
HumanTaskUiArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateHumanTaskUiMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateHumanTaskUi{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateHumanTaskUi{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateHumanTaskUiValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateHumanTaskUi(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreateHumanTaskUi(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateHumanTaskUi",
}
}

173
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateHyperParameterTuningJob.go generated vendored Normal file
View File

@@ -0,0 +1,173 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Starts a hyperparameter tuning job. A hyperparameter tuning job finds the best
// version of a model by running many training jobs on your dataset using the
// algorithm you choose and values for hyperparameters within ranges that you
// specify. It then chooses the hyperparameter values that result in a model that
// performs the best, as measured by an objective metric that you choose.
func (c *Client) CreateHyperParameterTuningJob(ctx context.Context, params *CreateHyperParameterTuningJobInput, optFns ...func(*Options)) (*CreateHyperParameterTuningJobOutput, error) {
if params == nil {
params = &CreateHyperParameterTuningJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateHyperParameterTuningJob", params, optFns, c.addOperationCreateHyperParameterTuningJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateHyperParameterTuningJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateHyperParameterTuningJobInput struct {
// The HyperParameterTuningJobConfig object that describes the tuning job,
// including the search strategy, the objective metric used to evaluate training
// jobs, ranges of parameters to search, and resource limits for the tuning job.
// For more information, see How Hyperparameter Tuning Works
// (https://docs.aws.amazon.com/sagemaker/latest/dg/automatic-model-tuning-how-it-works.html).
//
// This member is required.
HyperParameterTuningJobConfig *types.HyperParameterTuningJobConfig
// The name of the tuning job. This name is the prefix for the names of all
// training jobs that this tuning job launches. The name must be unique within the
// same Amazon Web Services account and Amazon Web Services Region. The name must
// have 1 to 32 characters. Valid characters are a-z, A-Z, 0-9, and : + = @ _ % -
// (hyphen). The name is not case sensitive.
//
// This member is required.
HyperParameterTuningJobName *string
// An array of key-value pairs. You can use tags to categorize your Amazon Web
// Services resources in different ways, for example, by purpose, owner, or
// environment. For more information, see Tagging Amazon Web Services Resources
// (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html). Tags that you
// specify for the tuning job are also added to all training jobs that the tuning
// job launches.
Tags []types.Tag
// The HyperParameterTrainingJobDefinition object that describes the training jobs
// that this tuning job launches, including static hyperparameters, input data
// configuration, output data configuration, resource configuration, and stopping
// condition.
TrainingJobDefinition *types.HyperParameterTrainingJobDefinition
// A list of the HyperParameterTrainingJobDefinition objects launched for this
// tuning job.
TrainingJobDefinitions []types.HyperParameterTrainingJobDefinition
// Specifies the configuration for starting the hyperparameter tuning job using one
// or more previous tuning jobs as a starting point. The results of previous tuning
// jobs are used to inform which combinations of hyperparameters to search over in
// the new tuning job. All training jobs launched by the new hyperparameter tuning
// job are evaluated by using the objective metric. If you specify
// IDENTICAL_DATA_AND_ALGORITHM as the WarmStartType value for the warm start
// configuration, the training job that performs the best in the new tuning job is
// compared to the best training jobs from the parent tuning jobs. From these, the
// training job that performs the best as measured by the objective metric is
// returned as the overall best training job. All training jobs launched by parent
// hyperparameter tuning jobs and the new hyperparameter tuning jobs count against
// the limit of training jobs for the tuning job.
WarmStartConfig *types.HyperParameterTuningJobWarmStartConfig
noSmithyDocumentSerde
}
type CreateHyperParameterTuningJobOutput struct {
// The Amazon Resource Name (ARN) of the tuning job. Amazon SageMaker assigns an
// ARN to a hyperparameter tuning job when you create it.
//
// This member is required.
HyperParameterTuningJobArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateHyperParameterTuningJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateHyperParameterTuningJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateHyperParameterTuningJob{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateHyperParameterTuningJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateHyperParameterTuningJob(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreateHyperParameterTuningJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateHyperParameterTuningJob",
}
}

139
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateImage.go generated vendored Normal file
View File

@@ -0,0 +1,139 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a custom SageMaker image. A SageMaker image is a set of image versions.
// Each image version represents a container image stored in Amazon Container
// Registry (ECR). For more information, see Bring your own SageMaker image
// (https://docs.aws.amazon.com/sagemaker/latest/dg/studio-byoi.html).
func (c *Client) CreateImage(ctx context.Context, params *CreateImageInput, optFns ...func(*Options)) (*CreateImageOutput, error) {
if params == nil {
params = &CreateImageInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateImage", params, optFns, c.addOperationCreateImageMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateImageOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateImageInput struct {
// The name of the image. Must be unique to your account.
//
// This member is required.
ImageName *string
// The Amazon Resource Name (ARN) of an IAM role that enables Amazon SageMaker to
// perform tasks on your behalf.
//
// This member is required.
RoleArn *string
// The description of the image.
Description *string
// The display name of the image. If not provided, ImageName is displayed.
DisplayName *string
// A list of tags to apply to the image.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateImageOutput struct {
// The Amazon Resource Name (ARN) of the image.
ImageArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateImageMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateImage{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateImage{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateImageValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateImage(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreateImage(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateImage",
}
}

173
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateImageVersion.go generated vendored Normal file
View File

@@ -0,0 +1,173 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
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/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a version of the SageMaker image specified by ImageName. The version
// represents the Amazon Container Registry (ECR) container image specified by
// BaseImage.
func (c *Client) CreateImageVersion(ctx context.Context, params *CreateImageVersionInput, optFns ...func(*Options)) (*CreateImageVersionOutput, error) {
if params == nil {
params = &CreateImageVersionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateImageVersion", params, optFns, c.addOperationCreateImageVersionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateImageVersionOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateImageVersionInput struct {
// The registry path of the container image to use as the starting point for this
// version. The path is an Amazon Container Registry (ECR) URI in the following
// format: .dkr.ecr..amazonaws.com/
//
// This member is required.
BaseImage *string
// A unique ID. If not specified, the Amazon Web Services CLI and Amazon Web
// Services SDKs, such as the SDK for Python (Boto3), add a unique value to the
// call.
//
// This member is required.
ClientToken *string
// The ImageName of the Image to create a version of.
//
// This member is required.
ImageName *string
noSmithyDocumentSerde
}
type CreateImageVersionOutput struct {
// The Amazon Resource Name (ARN) of the image version.
ImageVersionArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateImageVersionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateImageVersion{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateImageVersion{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addIdempotencyToken_opCreateImageVersionMiddleware(stack, options); err != nil {
return err
}
if err = addOpCreateImageVersionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateImageVersion(options.Region), middleware.Before); 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
}
return nil
}
type idempotencyToken_initializeOpCreateImageVersion struct {
tokenProvider IdempotencyTokenProvider
}
func (*idempotencyToken_initializeOpCreateImageVersion) ID() string {
return "OperationIdempotencyTokenAutoFill"
}
func (m *idempotencyToken_initializeOpCreateImageVersion) 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.(*CreateImageVersionInput)
if !ok {
return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateImageVersionInput ")
}
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_opCreateImageVersionMiddleware(stack *middleware.Stack, cfg Options) error {
return stack.Initialize.Add(&idempotencyToken_initializeOpCreateImageVersion{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before)
}
func newServiceMetadataMiddleware_opCreateImageVersion(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateImageVersion",
}
}

316
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateLabelingJob.go generated vendored Normal file
View File

@@ -0,0 +1,316 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a job that uses workers to label the data objects in your input dataset.
// You can use the labeled data to train machine learning models. You can select
// your workforce from one of three providers:
//
// * A private workforce that you
// create. It can include employees, contractors, and outside experts. Use a
// private workforce when want the data to stay within your organization or when a
// specific set of skills is required.
//
// * One or more vendors that you select from
// the Amazon Web Services Marketplace. Vendors provide expertise in specific
// areas.
//
// * The Amazon Mechanical Turk workforce. This is the largest workforce,
// but it should only be used for public data or data that has been stripped of any
// personally identifiable information.
//
// You can also use automated data labeling
// to reduce the number of data objects that need to be labeled by a human.
// Automated data labeling uses active learning to determine if a data object can
// be labeled by machine or if it needs to be sent to a human worker. For more
// information, see Using Automated Data Labeling
// (https://docs.aws.amazon.com/sagemaker/latest/dg/sms-automated-labeling.html).
// The data objects to be labeled are contained in an Amazon S3 bucket. You create
// a manifest file that describes the location of each object. For more
// information, see Using Input and Output Data
// (https://docs.aws.amazon.com/sagemaker/latest/dg/sms-data.html). The output can
// be used as the manifest file for another labeling job or as training data for
// your machine learning models. You can use this operation to create a static
// labeling job or a streaming labeling job. A static labeling job stops if all
// data objects in the input manifest file identified in ManifestS3Uri have been
// labeled. A streaming labeling job runs perpetually until it is manually stopped,
// or remains idle for 10 days. You can send new data objects to an active
// (InProgress) streaming labeling job in real time. To learn how to create a
// static labeling job, see Create a Labeling Job (API)
// (https://docs.aws.amazon.com/sagemaker/latest/dg/sms-create-labeling-job-api.html)
// in the Amazon SageMaker Developer Guide. To learn how to create a streaming
// labeling job, see Create a Streaming Labeling Job
// (https://docs.aws.amazon.com/sagemaker/latest/dg/sms-streaming-create-job.html).
func (c *Client) CreateLabelingJob(ctx context.Context, params *CreateLabelingJobInput, optFns ...func(*Options)) (*CreateLabelingJobOutput, error) {
if params == nil {
params = &CreateLabelingJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateLabelingJob", params, optFns, c.addOperationCreateLabelingJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateLabelingJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateLabelingJobInput struct {
// Configures the labeling task and how it is presented to workers; including, but
// not limited to price, keywords, and batch size (task count).
//
// This member is required.
HumanTaskConfig *types.HumanTaskConfig
// Input data for the labeling job, such as the Amazon S3 location of the data
// objects and the location of the manifest file that describes the data objects.
// You must specify at least one of the following: S3DataSource or
// SnsDataSource.
//
// * Use SnsDataSource to specify an SNS input topic for a
// streaming labeling job. If you do not specify and SNS input topic ARN, Ground
// Truth will create a one-time labeling job that stops after all data objects in
// the input manifest file have been labeled.
//
// * Use S3DataSource to specify an
// input manifest file for both streaming and one-time labeling jobs. Adding an
// S3DataSource is optional if you use SnsDataSource to create a streaming labeling
// job.
//
// If you use the Amazon Mechanical Turk workforce, your input data should
// not include confidential information, personal information or protected health
// information. Use ContentClassifiers to specify that your data is free of
// personally identifiable information and adult content.
//
// This member is required.
InputConfig *types.LabelingJobInputConfig
// The attribute name to use for the label in the output manifest file. This is the
// key for the key/value pair formed with the label that a worker assigns to the
// object. The LabelAttributeName must meet the following requirements.
//
// * The name
// can't end with "-metadata".
//
// * If you are using one of the following built-in
// task types
// (https://docs.aws.amazon.com/sagemaker/latest/dg/sms-task-types.html), the
// attribute name must end with "-ref". If the task type you are using is not
// listed below, the attribute name must not end with "-ref".
//
// * Image semantic
// segmentation (SemanticSegmentation), and adjustment
// (AdjustmentSemanticSegmentation) and verification
// (VerificationSemanticSegmentation) labeling jobs for this task type.
//
// * Video
// frame object detection (VideoObjectDetection), and adjustment and verification
// (AdjustmentVideoObjectDetection) labeling jobs for this task type.
//
// * Video
// frame object tracking (VideoObjectTracking), and adjustment and verification
// (AdjustmentVideoObjectTracking) labeling jobs for this task type.
//
// * 3D point
// cloud semantic segmentation (3DPointCloudSemanticSegmentation), and adjustment
// and verification (Adjustment3DPointCloudSemanticSegmentation) labeling jobs for
// this task type.
//
// * 3D point cloud object tracking (3DPointCloudObjectTracking),
// and adjustment and verification (Adjustment3DPointCloudObjectTracking) labeling
// jobs for this task type.
//
// If you are creating an adjustment or verification
// labeling job, you must use a different LabelAttributeName than the one used in
// the original labeling job. The original labeling job is the Ground Truth
// labeling job that produced the labels that you want verified or adjusted. To
// learn more about adjustment and verification labeling jobs, see Verify and
// Adjust Labels
// (https://docs.aws.amazon.com/sagemaker/latest/dg/sms-verification-data.html).
//
// This member is required.
LabelAttributeName *string
// The name of the labeling job. This name is used to identify the job in a list of
// labeling jobs. Labeling job names must be unique within an Amazon Web Services
// account and region. LabelingJobName is not case sensitive. For example,
// Example-job and example-job are considered the same labeling job name by Ground
// Truth.
//
// This member is required.
LabelingJobName *string
// The location of the output data and the Amazon Web Services Key Management
// Service key ID for the key used to encrypt the output data, if any.
//
// This member is required.
OutputConfig *types.LabelingJobOutputConfig
// The Amazon Resource Number (ARN) that Amazon SageMaker assumes to perform tasks
// on your behalf during data labeling. You must grant this role the necessary
// permissions so that Amazon SageMaker can successfully complete data labeling.
//
// This member is required.
RoleArn *string
// The S3 URI of the file, referred to as a label category configuration file, that
// defines the categories used to label the data objects. For 3D point cloud and
// video frame task types, you can add label category attributes and frame
// attributes to your label category configuration file. To learn how, see Create a
// Labeling Category Configuration File for 3D Point Cloud Labeling Jobs
// (https://docs.aws.amazon.com/sagemaker/latest/dg/sms-point-cloud-label-category-config.html).
// For named entity recognition jobs, in addition to "labels", you must provide
// worker instructions in the label category configuration file using the
// "instructions" parameter: "instructions": {"shortInstruction":"
// Add header
//
//
// Add Instructions
//
// ", "fullInstruction":"Add additional instructions."}. For
// details and an example, see Create a Named Entity Recognition Labeling Job (API)
// (https://docs.aws.amazon.com/sagemaker/latest/dg/sms-named-entity-recg.html#sms-creating-ner-api).
// For all other built-in task types
// (https://docs.aws.amazon.com/sagemaker/latest/dg/sms-task-types.html) and custom
// tasks
// (https://docs.aws.amazon.com/sagemaker/latest/dg/sms-custom-templates.html),
// your label category configuration file must be a JSON file in the following
// format. Identify the labels you want to use by replacing label_1,
// label_2,...,label_n with your label categories. {
// "document-version":
// "2018-11-28",
//
// "labels": [{"label": "label_1"},{"label":
// "label_2"},...{"label": "label_n"}]
//
// } Note the following about the label
// category configuration file:
//
// * For image classification and text classification
// (single and multi-label) you must specify at least two label categories. For all
// other task types, the minimum number of label categories required is one.
//
// *
// Each label category must be unique, you cannot specify duplicate label
// categories.
//
// * If you create a 3D point cloud or video frame adjustment or
// verification labeling job, you must include auditLabelAttributeName in the label
// category configuration. Use this parameter to enter the LabelAttributeName
// (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateLabelingJob.html#sagemaker-CreateLabelingJob-request-LabelAttributeName)
// of the labeling job you want to adjust or verify annotations of.
LabelCategoryConfigS3Uri *string
// Configures the information required to perform automated data labeling.
LabelingJobAlgorithmsConfig *types.LabelingJobAlgorithmsConfig
// A set of conditions for stopping the labeling job. If any of the conditions are
// met, the job is automatically stopped. You can use these conditions to control
// the cost of data labeling.
StoppingConditions *types.LabelingJobStoppingConditions
// An array of key/value pairs. For more information, see Using Cost Allocation
// Tags
// (https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html#allocation-what)
// in the Amazon Web Services Billing and Cost Management User Guide.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateLabelingJobOutput struct {
// The Amazon Resource Name (ARN) of the labeling job. You use this ARN to identify
// the labeling job.
//
// This member is required.
LabelingJobArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateLabelingJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateLabelingJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateLabelingJob{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateLabelingJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateLabelingJob(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreateLabelingJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateLabelingJob",
}
}

186
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateModel.go generated vendored Normal file
View File

@@ -0,0 +1,186 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a model in Amazon SageMaker. In the request, you name the model and
// describe a primary container. For the primary container, you specify the Docker
// image that contains inference code, artifacts (from prior training), and a
// custom environment map that the inference code uses when you deploy the model
// for predictions. Use this API to create a model if you want to use Amazon
// SageMaker hosting services or run a batch transform job. To host your model, you
// create an endpoint configuration with the CreateEndpointConfig API, and then
// create an endpoint with the CreateEndpoint API. Amazon SageMaker then deploys
// all of the containers that you defined for the model in the hosting environment.
// For an example that calls this method when deploying a model to Amazon SageMaker
// hosting services, see Deploy the Model to Amazon SageMaker Hosting Services
// (Amazon Web Services SDK for Python (Boto 3)).
// (https://docs.aws.amazon.com/sagemaker/latest/dg/ex1-deploy-model.html#ex1-deploy-model-boto)
// To run a batch transform using your model, you start a job with the
// CreateTransformJob API. Amazon SageMaker uses your model and your dataset to get
// inferences which are then saved to a specified S3 location. In the CreateModel
// request, you must define a container with the PrimaryContainer parameter. In the
// request, you also provide an IAM role that Amazon SageMaker can assume to access
// model artifacts and docker image for deployment on ML compute hosting instances
// or for batch transform jobs. In addition, you also use the IAM role to manage
// permissions the inference code needs. For example, if the inference code access
// any other Amazon Web Services resources, you grant necessary permissions via
// this role.
func (c *Client) CreateModel(ctx context.Context, params *CreateModelInput, optFns ...func(*Options)) (*CreateModelOutput, error) {
if params == nil {
params = &CreateModelInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateModel", params, optFns, c.addOperationCreateModelMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateModelOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateModelInput struct {
// The Amazon Resource Name (ARN) of the IAM role that Amazon SageMaker can assume
// to access model artifacts and docker image for deployment on ML compute
// instances or for batch transform jobs. Deploying on ML compute instances is part
// of model hosting. For more information, see Amazon SageMaker Roles
// (https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html). To be
// able to pass this role to Amazon SageMaker, the caller of this API must have the
// iam:PassRole permission.
//
// This member is required.
ExecutionRoleArn *string
// The name of the new model.
//
// This member is required.
ModelName *string
// Specifies the containers in the inference pipeline.
Containers []types.ContainerDefinition
// Isolates the model container. No inbound or outbound network calls can be made
// to or from the model container.
EnableNetworkIsolation bool
// Specifies details of how containers in a multi-container endpoint are called.
InferenceExecutionConfig *types.InferenceExecutionConfig
// The location of the primary docker image containing inference code, associated
// artifacts, and custom environment map that the inference code uses when the
// model is deployed for predictions.
PrimaryContainer *types.ContainerDefinition
// An array of key-value pairs. You can use tags to categorize your Amazon Web
// Services resources in different ways, for example, by purpose, owner, or
// environment. For more information, see Tagging Amazon Web Services Resources
// (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html).
Tags []types.Tag
// A VpcConfig object that specifies the VPC that you want your model to connect
// to. Control access to and from your model container by configuring the VPC.
// VpcConfig is used in hosting services and in batch transform. For more
// information, see Protect Endpoints by Using an Amazon Virtual Private Cloud
// (https://docs.aws.amazon.com/sagemaker/latest/dg/host-vpc.html) and Protect Data
// in Batch Transform Jobs by Using an Amazon Virtual Private Cloud
// (https://docs.aws.amazon.com/sagemaker/latest/dg/batch-vpc.html).
VpcConfig *types.VpcConfig
noSmithyDocumentSerde
}
type CreateModelOutput struct {
// The ARN of the model created in Amazon SageMaker.
//
// This member is required.
ModelArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateModelMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateModel{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateModel{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateModelValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateModel(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreateModel(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateModel",
}
}

165
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateModelBiasJobDefinition.go generated vendored Normal file
View File

@@ -0,0 +1,165 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates the definition for a model bias job.
func (c *Client) CreateModelBiasJobDefinition(ctx context.Context, params *CreateModelBiasJobDefinitionInput, optFns ...func(*Options)) (*CreateModelBiasJobDefinitionOutput, error) {
if params == nil {
params = &CreateModelBiasJobDefinitionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateModelBiasJobDefinition", params, optFns, c.addOperationCreateModelBiasJobDefinitionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateModelBiasJobDefinitionOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateModelBiasJobDefinitionInput struct {
// The name of the bias job definition. The name must be unique within an Amazon
// Web Services Region in the Amazon Web Services account.
//
// This member is required.
JobDefinitionName *string
// Identifies the resources to deploy for a monitoring job.
//
// This member is required.
JobResources *types.MonitoringResources
// Configures the model bias job to run a specified Docker container image.
//
// This member is required.
ModelBiasAppSpecification *types.ModelBiasAppSpecification
// Inputs for the model bias job.
//
// This member is required.
ModelBiasJobInput *types.ModelBiasJobInput
// The output configuration for monitoring jobs.
//
// This member is required.
ModelBiasJobOutputConfig *types.MonitoringOutputConfig
// The Amazon Resource Name (ARN) of an IAM role that Amazon SageMaker can assume
// to perform tasks on your behalf.
//
// This member is required.
RoleArn *string
// The baseline configuration for a model bias job.
ModelBiasBaselineConfig *types.ModelBiasBaselineConfig
// Networking options for a model bias job.
NetworkConfig *types.MonitoringNetworkConfig
// A time limit for how long the monitoring job is allowed to run before stopping.
StoppingCondition *types.MonitoringStoppingCondition
// (Optional) An array of key-value pairs. For more information, see Using Cost
// Allocation Tags
// (https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html#allocation-whatURL)
// in the Amazon Web Services Billing and Cost Management User Guide.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateModelBiasJobDefinitionOutput struct {
// The Amazon Resource Name (ARN) of the model bias job.
//
// This member is required.
JobDefinitionArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateModelBiasJobDefinitionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateModelBiasJobDefinition{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateModelBiasJobDefinition{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateModelBiasJobDefinitionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateModelBiasJobDefinition(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreateModelBiasJobDefinition(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateModelBiasJobDefinition",
}
}

166
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateModelExplainabilityJobDefinition.go generated vendored Normal file
View File

@@ -0,0 +1,166 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates the definition for a model explainability job.
func (c *Client) CreateModelExplainabilityJobDefinition(ctx context.Context, params *CreateModelExplainabilityJobDefinitionInput, optFns ...func(*Options)) (*CreateModelExplainabilityJobDefinitionOutput, error) {
if params == nil {
params = &CreateModelExplainabilityJobDefinitionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateModelExplainabilityJobDefinition", params, optFns, c.addOperationCreateModelExplainabilityJobDefinitionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateModelExplainabilityJobDefinitionOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateModelExplainabilityJobDefinitionInput struct {
// The name of the model explainability job definition. The name must be unique
// within an Amazon Web Services Region in the Amazon Web Services account.
//
// This member is required.
JobDefinitionName *string
// Identifies the resources to deploy for a monitoring job.
//
// This member is required.
JobResources *types.MonitoringResources
// Configures the model explainability job to run a specified Docker container
// image.
//
// This member is required.
ModelExplainabilityAppSpecification *types.ModelExplainabilityAppSpecification
// Inputs for the model explainability job.
//
// This member is required.
ModelExplainabilityJobInput *types.ModelExplainabilityJobInput
// The output configuration for monitoring jobs.
//
// This member is required.
ModelExplainabilityJobOutputConfig *types.MonitoringOutputConfig
// The Amazon Resource Name (ARN) of an IAM role that Amazon SageMaker can assume
// to perform tasks on your behalf.
//
// This member is required.
RoleArn *string
// The baseline configuration for a model explainability job.
ModelExplainabilityBaselineConfig *types.ModelExplainabilityBaselineConfig
// Networking options for a model explainability job.
NetworkConfig *types.MonitoringNetworkConfig
// A time limit for how long the monitoring job is allowed to run before stopping.
StoppingCondition *types.MonitoringStoppingCondition
// (Optional) An array of key-value pairs. For more information, see Using Cost
// Allocation Tags
// (https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html#allocation-whatURL)
// in the Amazon Web Services Billing and Cost Management User Guide.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateModelExplainabilityJobDefinitionOutput struct {
// The Amazon Resource Name (ARN) of the model explainability job.
//
// This member is required.
JobDefinitionArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateModelExplainabilityJobDefinitionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateModelExplainabilityJobDefinition{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateModelExplainabilityJobDefinition{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateModelExplainabilityJobDefinitionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateModelExplainabilityJobDefinition(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreateModelExplainabilityJobDefinition(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateModelExplainabilityJobDefinition",
}
}

227
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateModelPackage.go generated vendored Normal file
View File

@@ -0,0 +1,227 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a model package that you can use to create Amazon SageMaker models or
// list on Amazon Web Services Marketplace, or a versioned model that is part of a
// model group. Buyers can subscribe to model packages listed on Amazon Web
// Services Marketplace to create models in Amazon SageMaker. To create a model
// package by specifying a Docker container that contains your inference code and
// the Amazon S3 location of your model artifacts, provide values for
// InferenceSpecification. To create a model from an algorithm resource that you
// created or subscribed to in Amazon Web Services Marketplace, provide a value for
// SourceAlgorithmSpecification. There are two types of model packages:
//
// *
// Versioned - a model that is part of a model group in the model registry.
//
// *
// Unversioned - a model package that is not part of a model group.
func (c *Client) CreateModelPackage(ctx context.Context, params *CreateModelPackageInput, optFns ...func(*Options)) (*CreateModelPackageOutput, error) {
if params == nil {
params = &CreateModelPackageInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateModelPackage", params, optFns, c.addOperationCreateModelPackageMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateModelPackageOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateModelPackageInput struct {
// Whether to certify the model package for listing on Amazon Web Services
// Marketplace. This parameter is optional for unversioned models, and does not
// apply to versioned models.
CertifyForMarketplace bool
// A unique token that guarantees that the call to this API is idempotent.
ClientToken *string
// Specifies details about inference jobs that can be run with models based on this
// model package, including the following:
//
// * The Amazon ECR paths of containers
// that contain the inference code and model artifacts.
//
// * The instance types that
// the model package supports for transform jobs and real-time endpoints used for
// inference.
//
// * The input and output content formats that the model package
// supports for inference.
InferenceSpecification *types.InferenceSpecification
// Metadata properties of the tracking entity, trial, or trial component.
MetadataProperties *types.MetadataProperties
// Whether the model is approved for deployment. This parameter is optional for
// versioned models, and does not apply to unversioned models. For versioned
// models, the value of this parameter must be set to Approved to deploy the model.
ModelApprovalStatus types.ModelApprovalStatus
// A structure that contains model metrics reports.
ModelMetrics *types.ModelMetrics
// A description of the model package.
ModelPackageDescription *string
// The name of the model group that this model version belongs to. This parameter
// is required for versioned models, and does not apply to unversioned models.
ModelPackageGroupName *string
// The name of the model package. The name must have 1 to 63 characters. Valid
// characters are a-z, A-Z, 0-9, and - (hyphen). This parameter is required for
// unversioned models. It is not applicable to versioned models.
ModelPackageName *string
// Details about the algorithm that was used to create the model package.
SourceAlgorithmSpecification *types.SourceAlgorithmSpecification
// A list of key value pairs associated with the model. For more information, see
// Tagging Amazon Web Services resources
// (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html) in the Amazon
// Web Services General Reference Guide.
Tags []types.Tag
// Specifies configurations for one or more transform jobs that Amazon SageMaker
// runs to test the model package.
ValidationSpecification *types.ModelPackageValidationSpecification
noSmithyDocumentSerde
}
type CreateModelPackageOutput struct {
// The Amazon Resource Name (ARN) of the new model package.
//
// This member is required.
ModelPackageArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateModelPackageMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateModelPackage{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateModelPackage{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addIdempotencyToken_opCreateModelPackageMiddleware(stack, options); err != nil {
return err
}
if err = addOpCreateModelPackageValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateModelPackage(options.Region), middleware.Before); 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
}
return nil
}
type idempotencyToken_initializeOpCreateModelPackage struct {
tokenProvider IdempotencyTokenProvider
}
func (*idempotencyToken_initializeOpCreateModelPackage) ID() string {
return "OperationIdempotencyTokenAutoFill"
}
func (m *idempotencyToken_initializeOpCreateModelPackage) 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.(*CreateModelPackageInput)
if !ok {
return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateModelPackageInput ")
}
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_opCreateModelPackageMiddleware(stack *middleware.Stack, cfg Options) error {
return stack.Initialize.Add(&idempotencyToken_initializeOpCreateModelPackage{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before)
}
func newServiceMetadataMiddleware_opCreateModelPackage(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateModelPackage",
}
}

132
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateModelPackageGroup.go generated vendored Normal file
View File

@@ -0,0 +1,132 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a model group. A model group contains a group of model versions.
func (c *Client) CreateModelPackageGroup(ctx context.Context, params *CreateModelPackageGroupInput, optFns ...func(*Options)) (*CreateModelPackageGroupOutput, error) {
if params == nil {
params = &CreateModelPackageGroupInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateModelPackageGroup", params, optFns, c.addOperationCreateModelPackageGroupMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateModelPackageGroupOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateModelPackageGroupInput struct {
// The name of the model group.
//
// This member is required.
ModelPackageGroupName *string
// A description for the model group.
ModelPackageGroupDescription *string
// A list of key value pairs associated with the model group. For more information,
// see Tagging Amazon Web Services resources
// (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html) in the Amazon
// Web Services General Reference Guide.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateModelPackageGroupOutput struct {
// The Amazon Resource Name (ARN) of the model group.
//
// This member is required.
ModelPackageGroupArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateModelPackageGroupMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateModelPackageGroup{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateModelPackageGroup{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateModelPackageGroupValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateModelPackageGroup(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreateModelPackageGroup(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateModelPackageGroup",
}
}

166
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateModelQualityJobDefinition.go generated vendored Normal file
View File

@@ -0,0 +1,166 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a definition for a job that monitors model quality and drift. For
// information about model monitor, see Amazon SageMaker Model Monitor
// (https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor.html).
func (c *Client) CreateModelQualityJobDefinition(ctx context.Context, params *CreateModelQualityJobDefinitionInput, optFns ...func(*Options)) (*CreateModelQualityJobDefinitionOutput, error) {
if params == nil {
params = &CreateModelQualityJobDefinitionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateModelQualityJobDefinition", params, optFns, c.addOperationCreateModelQualityJobDefinitionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateModelQualityJobDefinitionOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateModelQualityJobDefinitionInput struct {
// The name of the monitoring job definition.
//
// This member is required.
JobDefinitionName *string
// Identifies the resources to deploy for a monitoring job.
//
// This member is required.
JobResources *types.MonitoringResources
// The container that runs the monitoring job.
//
// This member is required.
ModelQualityAppSpecification *types.ModelQualityAppSpecification
// A list of the inputs that are monitored. Currently endpoints are supported.
//
// This member is required.
ModelQualityJobInput *types.ModelQualityJobInput
// The output configuration for monitoring jobs.
//
// This member is required.
ModelQualityJobOutputConfig *types.MonitoringOutputConfig
// The Amazon Resource Name (ARN) of an IAM role that Amazon SageMaker can assume
// to perform tasks on your behalf.
//
// This member is required.
RoleArn *string
// Specifies the constraints and baselines for the monitoring job.
ModelQualityBaselineConfig *types.ModelQualityBaselineConfig
// Specifies the network configuration for the monitoring job.
NetworkConfig *types.MonitoringNetworkConfig
// A time limit for how long the monitoring job is allowed to run before stopping.
StoppingCondition *types.MonitoringStoppingCondition
// (Optional) An array of key-value pairs. For more information, see Using Cost
// Allocation Tags
// (https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html#allocation-whatURL)
// in the Amazon Web Services Billing and Cost Management User Guide.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateModelQualityJobDefinitionOutput struct {
// The Amazon Resource Name (ARN) of the model quality monitoring job.
//
// This member is required.
JobDefinitionArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateModelQualityJobDefinitionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateModelQualityJobDefinition{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateModelQualityJobDefinition{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateModelQualityJobDefinitionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateModelQualityJobDefinition(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreateModelQualityJobDefinition(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateModelQualityJobDefinition",
}
}

137
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateMonitoringSchedule.go generated vendored Normal file
View File

@@ -0,0 +1,137 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a schedule that regularly starts Amazon SageMaker Processing Jobs to
// monitor the data captured for an Amazon SageMaker Endoint.
func (c *Client) CreateMonitoringSchedule(ctx context.Context, params *CreateMonitoringScheduleInput, optFns ...func(*Options)) (*CreateMonitoringScheduleOutput, error) {
if params == nil {
params = &CreateMonitoringScheduleInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateMonitoringSchedule", params, optFns, c.addOperationCreateMonitoringScheduleMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateMonitoringScheduleOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateMonitoringScheduleInput struct {
// The configuration object that specifies the monitoring schedule and defines the
// monitoring job.
//
// This member is required.
MonitoringScheduleConfig *types.MonitoringScheduleConfig
// The name of the monitoring schedule. The name must be unique within an Amazon
// Web Services Region within an Amazon Web Services account.
//
// This member is required.
MonitoringScheduleName *string
// (Optional) An array of key-value pairs. For more information, see Using Cost
// Allocation Tags
// (https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html#allocation-whatURL)
// in the Amazon Web Services Billing and Cost Management User Guide.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateMonitoringScheduleOutput struct {
// The Amazon Resource Name (ARN) of the monitoring schedule.
//
// This member is required.
MonitoringScheduleArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateMonitoringScheduleMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateMonitoringSchedule{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateMonitoringSchedule{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateMonitoringScheduleValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateMonitoringSchedule(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreateMonitoringSchedule(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateMonitoringSchedule",
}
}

252
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateNotebookInstance.go generated vendored Normal file
View File

@@ -0,0 +1,252 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates an Amazon SageMaker notebook instance. A notebook instance is a machine
// learning (ML) compute instance running on a Jupyter notebook. In a
// CreateNotebookInstance request, specify the type of ML compute instance that you
// want to run. Amazon SageMaker launches the instance, installs common libraries
// that you can use to explore datasets for model training, and attaches an ML
// storage volume to the notebook instance. Amazon SageMaker also provides a set of
// example notebooks. Each notebook demonstrates how to use Amazon SageMaker with a
// specific algorithm or with a machine learning framework. After receiving the
// request, Amazon SageMaker does the following:
//
// * Creates a network interface in
// the Amazon SageMaker VPC.
//
// * (Option) If you specified SubnetId, Amazon
// SageMaker creates a network interface in your own VPC, which is inferred from
// the subnet ID that you provide in the input. When creating this network
// interface, Amazon SageMaker attaches the security group that you specified in
// the request to the network interface that it creates in your VPC.
//
// * Launches an
// EC2 instance of the type specified in the request in the Amazon SageMaker VPC.
// If you specified SubnetId of your VPC, Amazon SageMaker specifies both network
// interfaces when launching this instance. This enables inbound traffic from your
// own VPC to the notebook instance, assuming that the security groups allow
// it.
//
// After creating the notebook instance, Amazon SageMaker returns its Amazon
// Resource Name (ARN). You can't change the name of a notebook instance after you
// create it. After Amazon SageMaker creates the notebook instance, you can connect
// to the Jupyter server and work in Jupyter notebooks. For example, you can write
// code to explore a dataset that you can use for model training, train a model,
// host models by creating Amazon SageMaker endpoints, and validate hosted models.
// For more information, see How It Works
// (https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works.html).
func (c *Client) CreateNotebookInstance(ctx context.Context, params *CreateNotebookInstanceInput, optFns ...func(*Options)) (*CreateNotebookInstanceOutput, error) {
if params == nil {
params = &CreateNotebookInstanceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateNotebookInstance", params, optFns, c.addOperationCreateNotebookInstanceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateNotebookInstanceOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateNotebookInstanceInput struct {
// The type of ML compute instance to launch for the notebook instance.
//
// This member is required.
InstanceType types.InstanceType
// The name of the new notebook instance.
//
// This member is required.
NotebookInstanceName *string
// When you send any requests to Amazon Web Services resources from the notebook
// instance, Amazon SageMaker assumes this role to perform tasks on your behalf.
// You must grant this role necessary permissions so Amazon SageMaker can perform
// these tasks. The policy must allow the Amazon SageMaker service principal
// (sagemaker.amazonaws.com) permissions to assume this role. For more information,
// see Amazon SageMaker Roles
// (https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html). To be
// able to pass this role to Amazon SageMaker, the caller of this API must have the
// iam:PassRole permission.
//
// This member is required.
RoleArn *string
// A list of Elastic Inference (EI) instance types to associate with this notebook
// instance. Currently, only one instance type can be associated with a notebook
// instance. For more information, see Using Elastic Inference in Amazon SageMaker
// (https://docs.aws.amazon.com/sagemaker/latest/dg/ei.html).
AcceleratorTypes []types.NotebookInstanceAcceleratorType
// An array of up to three Git repositories to associate with the notebook
// instance. These can be either the names of Git repositories stored as resources
// in your account, or the URL of Git repositories in Amazon Web Services
// CodeCommit
// (https://docs.aws.amazon.com/codecommit/latest/userguide/welcome.html) or in any
// other Git repository. These repositories are cloned at the same level as the
// default repository of your notebook instance. For more information, see
// Associating Git Repositories with Amazon SageMaker Notebook Instances
// (https://docs.aws.amazon.com/sagemaker/latest/dg/nbi-git-repo.html).
AdditionalCodeRepositories []string
// A Git repository to associate with the notebook instance as its default code
// repository. This can be either the name of a Git repository stored as a resource
// in your account, or the URL of a Git repository in Amazon Web Services
// CodeCommit
// (https://docs.aws.amazon.com/codecommit/latest/userguide/welcome.html) or in any
// other Git repository. When you open a notebook instance, it opens in the
// directory that contains this repository. For more information, see Associating
// Git Repositories with Amazon SageMaker Notebook Instances
// (https://docs.aws.amazon.com/sagemaker/latest/dg/nbi-git-repo.html).
DefaultCodeRepository *string
// Sets whether Amazon SageMaker provides internet access to the notebook instance.
// If you set this to Disabled this notebook instance is able to access resources
// only in your VPC, and is not be able to connect to Amazon SageMaker training and
// endpoint services unless you configure a NAT Gateway in your VPC. For more
// information, see Notebook Instances Are Internet-Enabled by Default
// (https://docs.aws.amazon.com/sagemaker/latest/dg/appendix-additional-considerations.html#appendix-notebook-and-internet-access).
// You can set the value of this parameter to Disabled only if you set a value for
// the SubnetId parameter.
DirectInternetAccess types.DirectInternetAccess
// The Amazon Resource Name (ARN) of a Amazon Web Services Key Management Service
// key that Amazon SageMaker uses to encrypt data on the storage volume attached to
// your notebook instance. The KMS key you provide must be enabled. For
// information, see Enabling and Disabling Keys
// (https://docs.aws.amazon.com/kms/latest/developerguide/enabling-keys.html) in
// the Amazon Web Services Key Management Service Developer Guide.
KmsKeyId *string
// The name of a lifecycle configuration to associate with the notebook instance.
// For information about lifestyle configurations, see Step 2.1: (Optional)
// Customize a Notebook Instance
// (https://docs.aws.amazon.com/sagemaker/latest/dg/notebook-lifecycle-config.html).
LifecycleConfigName *string
// The platform identifier of the notebook instance runtime environment.
PlatformIdentifier *string
// Whether root access is enabled or disabled for users of the notebook instance.
// The default value is Enabled. Lifecycle configurations need root access to be
// able to set up a notebook instance. Because of this, lifecycle configurations
// associated with a notebook instance always run with root access even if you
// disable root access for users.
RootAccess types.RootAccess
// The VPC security group IDs, in the form sg-xxxxxxxx. The security groups must be
// for the same VPC as specified in the subnet.
SecurityGroupIds []string
// The ID of the subnet in a VPC to which you would like to have a connectivity
// from your ML compute instance.
SubnetId *string
// An array of key-value pairs. You can use tags to categorize your Amazon Web
// Services resources in different ways, for example, by purpose, owner, or
// environment. For more information, see Tagging Amazon Web Services Resources
// (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html).
Tags []types.Tag
// The size, in GB, of the ML storage volume to attach to the notebook instance.
// The default value is 5 GB.
VolumeSizeInGB *int32
noSmithyDocumentSerde
}
type CreateNotebookInstanceOutput struct {
// The Amazon Resource Name (ARN) of the notebook instance.
NotebookInstanceArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateNotebookInstanceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateNotebookInstance{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateNotebookInstance{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateNotebookInstanceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateNotebookInstance(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreateNotebookInstance(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateNotebookInstance",
}
}

142
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateNotebookInstanceLifecycleConfig.go generated vendored Normal file
View File

@@ -0,0 +1,142 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a lifecycle configuration that you can associate with a notebook
// instance. A lifecycle configuration is a collection of shell scripts that run
// when you create or start a notebook instance. Each lifecycle configuration
// script has a limit of 16384 characters. The value of the $PATH environment
// variable that is available to both scripts is /sbin:bin:/usr/sbin:/usr/bin. View
// CloudWatch Logs for notebook instance lifecycle configurations in log group
// /aws/sagemaker/NotebookInstances in log stream
// [notebook-instance-name]/[LifecycleConfigHook]. Lifecycle configuration scripts
// cannot run for longer than 5 minutes. If a script runs for longer than 5
// minutes, it fails and the notebook instance is not created or started. For
// information about notebook instance lifestyle configurations, see Step 2.1:
// (Optional) Customize a Notebook Instance
// (https://docs.aws.amazon.com/sagemaker/latest/dg/notebook-lifecycle-config.html).
func (c *Client) CreateNotebookInstanceLifecycleConfig(ctx context.Context, params *CreateNotebookInstanceLifecycleConfigInput, optFns ...func(*Options)) (*CreateNotebookInstanceLifecycleConfigOutput, error) {
if params == nil {
params = &CreateNotebookInstanceLifecycleConfigInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateNotebookInstanceLifecycleConfig", params, optFns, c.addOperationCreateNotebookInstanceLifecycleConfigMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateNotebookInstanceLifecycleConfigOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateNotebookInstanceLifecycleConfigInput struct {
// The name of the lifecycle configuration.
//
// This member is required.
NotebookInstanceLifecycleConfigName *string
// A shell script that runs only once, when you create a notebook instance. The
// shell script must be a base64-encoded string.
OnCreate []types.NotebookInstanceLifecycleHook
// A shell script that runs every time you start a notebook instance, including
// when you create the notebook instance. The shell script must be a base64-encoded
// string.
OnStart []types.NotebookInstanceLifecycleHook
noSmithyDocumentSerde
}
type CreateNotebookInstanceLifecycleConfigOutput struct {
// The Amazon Resource Name (ARN) of the lifecycle configuration.
NotebookInstanceLifecycleConfigArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateNotebookInstanceLifecycleConfigMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateNotebookInstanceLifecycleConfig{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateNotebookInstanceLifecycleConfig{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateNotebookInstanceLifecycleConfigValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateNotebookInstanceLifecycleConfig(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreateNotebookInstanceLifecycleConfig(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateNotebookInstanceLifecycleConfig",
}
}

184
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreatePipeline.go generated vendored Normal file
View File

@@ -0,0 +1,184 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a pipeline using a JSON pipeline definition.
func (c *Client) CreatePipeline(ctx context.Context, params *CreatePipelineInput, optFns ...func(*Options)) (*CreatePipelineOutput, error) {
if params == nil {
params = &CreatePipelineInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreatePipeline", params, optFns, c.addOperationCreatePipelineMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreatePipelineOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreatePipelineInput struct {
// A unique, case-sensitive identifier that you provide to ensure the idempotency
// of the operation. An idempotent operation completes no more than one time.
//
// This member is required.
ClientRequestToken *string
// The JSON pipeline definition of the pipeline.
//
// This member is required.
PipelineDefinition *string
// The name of the pipeline.
//
// This member is required.
PipelineName *string
// The Amazon Resource Name (ARN) of the role used by the pipeline to access and
// create resources.
//
// This member is required.
RoleArn *string
// A description of the pipeline.
PipelineDescription *string
// The display name of the pipeline.
PipelineDisplayName *string
// A list of tags to apply to the created pipeline.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreatePipelineOutput struct {
// The Amazon Resource Name (ARN) of the created pipeline.
PipelineArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreatePipelineMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreatePipeline{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreatePipeline{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addIdempotencyToken_opCreatePipelineMiddleware(stack, options); err != nil {
return err
}
if err = addOpCreatePipelineValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreatePipeline(options.Region), middleware.Before); 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
}
return nil
}
type idempotencyToken_initializeOpCreatePipeline struct {
tokenProvider IdempotencyTokenProvider
}
func (*idempotencyToken_initializeOpCreatePipeline) ID() string {
return "OperationIdempotencyTokenAutoFill"
}
func (m *idempotencyToken_initializeOpCreatePipeline) 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.(*CreatePipelineInput)
if !ok {
return out, metadata, fmt.Errorf("expected middleware input to be of type *CreatePipelineInput ")
}
if input.ClientRequestToken == nil {
t, err := m.tokenProvider.GetIdempotencyToken()
if err != nil {
return out, metadata, err
}
input.ClientRequestToken = &t
}
return next.HandleInitialize(ctx, in)
}
func addIdempotencyToken_opCreatePipelineMiddleware(stack *middleware.Stack, cfg Options) error {
return stack.Initialize.Add(&idempotencyToken_initializeOpCreatePipeline{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before)
}
func newServiceMetadataMiddleware_opCreatePipeline(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreatePipeline",
}
}

148
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreatePresignedDomainUrl.go generated vendored Normal file
View File

@@ -0,0 +1,148 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a URL for a specified UserProfile in a Domain. When accessed in a web
// browser, the user will be automatically signed in to Amazon SageMaker Studio,
// and granted access to all of the Apps and files associated with the Domain's
// Amazon Elastic File System (EFS) volume. This operation can only be called when
// the authentication mode equals IAM. The IAM role or user used to call this API
// defines the permissions to access the app. Once the presigned URL is created, no
// additional permission is required to access this URL. IAM authorization policies
// for this API are also enforced for every HTTP request and WebSocket frame that
// attempts to connect to the app. You can restrict access to this API and to the
// URL that it returns to a list of IP addresses, Amazon VPCs or Amazon VPC
// Endpoints that you specify. For more information, see Connect to SageMaker
// Studio Through an Interface VPC Endpoint
// (https://docs.aws.amazon.com/sagemaker/latest/dg/studio-interface-endpoint.html)
// . The URL that you get from a call to CreatePresignedDomainUrl has a default
// timeout of 5 minutes. You can configure this value using ExpiresInSeconds. If
// you try to use the URL after the timeout limit expires, you are directed to the
// Amazon Web Services console sign-in page.
func (c *Client) CreatePresignedDomainUrl(ctx context.Context, params *CreatePresignedDomainUrlInput, optFns ...func(*Options)) (*CreatePresignedDomainUrlOutput, error) {
if params == nil {
params = &CreatePresignedDomainUrlInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreatePresignedDomainUrl", params, optFns, c.addOperationCreatePresignedDomainUrlMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreatePresignedDomainUrlOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreatePresignedDomainUrlInput struct {
// The domain ID.
//
// This member is required.
DomainId *string
// The name of the UserProfile to sign-in as.
//
// This member is required.
UserProfileName *string
// The number of seconds until the pre-signed URL expires. This value defaults to
// 300.
ExpiresInSeconds *int32
// The session expiration duration in seconds. This value defaults to 43200.
SessionExpirationDurationInSeconds *int32
noSmithyDocumentSerde
}
type CreatePresignedDomainUrlOutput struct {
// The presigned URL.
AuthorizedUrl *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreatePresignedDomainUrlMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreatePresignedDomainUrl{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreatePresignedDomainUrl{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreatePresignedDomainUrlValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreatePresignedDomainUrl(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreatePresignedDomainUrl(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreatePresignedDomainUrl",
}
}

140
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreatePresignedNotebookInstanceUrl.go generated vendored Normal file
View File

@@ -0,0 +1,140 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Returns a URL that you can use to connect to the Jupyter server from a notebook
// instance. In the Amazon SageMaker console, when you choose Open next to a
// notebook instance, Amazon SageMaker opens a new tab showing the Jupyter server
// home page from the notebook instance. The console uses this API to get the URL
// and show the page. The IAM role or user used to call this API defines the
// permissions to access the notebook instance. Once the presigned URL is created,
// no additional permission is required to access this URL. IAM authorization
// policies for this API are also enforced for every HTTP request and WebSocket
// frame that attempts to connect to the notebook instance. You can restrict access
// to this API and to the URL that it returns to a list of IP addresses that you
// specify. Use the NotIpAddress condition operator and the aws:SourceIP condition
// context key to specify the list of IP addresses that you want to have access to
// the notebook instance. For more information, see Limit Access to a Notebook
// Instance by IP Address
// (https://docs.aws.amazon.com/sagemaker/latest/dg/security_iam_id-based-policy-examples.html#nbi-ip-filter).
// The URL that you get from a call to CreatePresignedNotebookInstanceUrl is valid
// only for 5 minutes. If you try to use the URL after the 5-minute limit expires,
// you are directed to the Amazon Web Services console sign-in page.
func (c *Client) CreatePresignedNotebookInstanceUrl(ctx context.Context, params *CreatePresignedNotebookInstanceUrlInput, optFns ...func(*Options)) (*CreatePresignedNotebookInstanceUrlOutput, error) {
if params == nil {
params = &CreatePresignedNotebookInstanceUrlInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreatePresignedNotebookInstanceUrl", params, optFns, c.addOperationCreatePresignedNotebookInstanceUrlMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreatePresignedNotebookInstanceUrlOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreatePresignedNotebookInstanceUrlInput struct {
// The name of the notebook instance.
//
// This member is required.
NotebookInstanceName *string
// The duration of the session, in seconds. The default is 12 hours.
SessionExpirationDurationInSeconds *int32
noSmithyDocumentSerde
}
type CreatePresignedNotebookInstanceUrlOutput struct {
// A JSON object that contains the URL string.
AuthorizedUrl *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreatePresignedNotebookInstanceUrlMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreatePresignedNotebookInstanceUrl{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreatePresignedNotebookInstanceUrl{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreatePresignedNotebookInstanceUrlValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreatePresignedNotebookInstanceUrl(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreatePresignedNotebookInstanceUrl(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreatePresignedNotebookInstanceUrl",
}
}

178
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateProcessingJob.go generated vendored Normal file
View File

@@ -0,0 +1,178 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a processing job.
func (c *Client) CreateProcessingJob(ctx context.Context, params *CreateProcessingJobInput, optFns ...func(*Options)) (*CreateProcessingJobOutput, error) {
if params == nil {
params = &CreateProcessingJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateProcessingJob", params, optFns, c.addOperationCreateProcessingJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateProcessingJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateProcessingJobInput struct {
// Configures the processing job to run a specified Docker container image.
//
// This member is required.
AppSpecification *types.AppSpecification
// The name of the processing job. The name must be unique within an Amazon Web
// Services Region in the Amazon Web Services account.
//
// This member is required.
ProcessingJobName *string
// Identifies the resources, ML compute instances, and ML storage volumes to deploy
// for a processing job. In distributed training, you specify more than one
// instance.
//
// This member is required.
ProcessingResources *types.ProcessingResources
// The Amazon Resource Name (ARN) of an IAM role that Amazon SageMaker can assume
// to perform tasks on your behalf.
//
// This member is required.
RoleArn *string
// The environment variables to set in the Docker container. Up to 100 key and
// values entries in the map are supported.
Environment map[string]string
// Associates a SageMaker job as a trial component with an experiment and trial.
// Specified when you call the following APIs:
//
// * CreateProcessingJob
//
// *
// CreateTrainingJob
//
// * CreateTransformJob
ExperimentConfig *types.ExperimentConfig
// Networking options for a processing job, such as whether to allow inbound and
// outbound network calls to and from processing containers, and the VPC subnets
// and security groups to use for VPC-enabled processing jobs.
NetworkConfig *types.NetworkConfig
// An array of inputs configuring the data to download into the processing
// container.
ProcessingInputs []types.ProcessingInput
// Output configuration for the processing job.
ProcessingOutputConfig *types.ProcessingOutputConfig
// The time limit for how long the processing job is allowed to run.
StoppingCondition *types.ProcessingStoppingCondition
// (Optional) An array of key-value pairs. For more information, see Using Cost
// Allocation Tags
// (https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html#allocation-whatURL)
// in the Amazon Web Services Billing and Cost Management User Guide.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateProcessingJobOutput struct {
// The Amazon Resource Name (ARN) of the processing job.
//
// This member is required.
ProcessingJobArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateProcessingJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateProcessingJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateProcessingJob{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateProcessingJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateProcessingJob(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreateProcessingJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateProcessingJob",
}
}

146
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateProject.go generated vendored Normal file
View File

@@ -0,0 +1,146 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a machine learning (ML) project that can contain one or more templates
// that set up an ML pipeline from training to deploying an approved model.
func (c *Client) CreateProject(ctx context.Context, params *CreateProjectInput, optFns ...func(*Options)) (*CreateProjectOutput, error) {
if params == nil {
params = &CreateProjectInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateProject", params, optFns, c.addOperationCreateProjectMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateProjectOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateProjectInput struct {
// The name of the project.
//
// This member is required.
ProjectName *string
// The product ID and provisioning artifact ID to provision a service catalog. For
// information, see What is Amazon Web Services Service Catalog
// (https://docs.aws.amazon.com/servicecatalog/latest/adminguide/introduction.html).
//
// This member is required.
ServiceCatalogProvisioningDetails *types.ServiceCatalogProvisioningDetails
// A description for the project.
ProjectDescription *string
// An array of key-value pairs that you want to use to organize and track your
// Amazon Web Services resource costs. For more information, see Tagging Amazon Web
// Services resources
// (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html) in the Amazon
// Web Services General Reference Guide.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateProjectOutput struct {
// The Amazon Resource Name (ARN) of the project.
//
// This member is required.
ProjectArn *string
// The ID of the new project.
//
// This member is required.
ProjectId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateProjectMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateProject{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateProject{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateProjectValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateProject(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreateProject(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateProject",
}
}

137
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateStudioLifecycleConfig.go generated vendored Normal file
View File

@@ -0,0 +1,137 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a new Studio Lifecycle Configuration.
func (c *Client) CreateStudioLifecycleConfig(ctx context.Context, params *CreateStudioLifecycleConfigInput, optFns ...func(*Options)) (*CreateStudioLifecycleConfigOutput, error) {
if params == nil {
params = &CreateStudioLifecycleConfigInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateStudioLifecycleConfig", params, optFns, c.addOperationCreateStudioLifecycleConfigMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateStudioLifecycleConfigOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateStudioLifecycleConfigInput struct {
// The App type that the Lifecycle Configuration is attached to.
//
// This member is required.
StudioLifecycleConfigAppType types.StudioLifecycleConfigAppType
// The content of your Studio Lifecycle Configuration script. This content must be
// base64 encoded.
//
// This member is required.
StudioLifecycleConfigContent *string
// The name of the Studio Lifecycle Configuration to create.
//
// This member is required.
StudioLifecycleConfigName *string
// Tags to be associated with the Lifecycle Configuration. Each tag consists of a
// key and an optional value. Tag keys must be unique per resource. Tags are
// searchable using the Search API.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateStudioLifecycleConfigOutput struct {
// The ARN of your created Lifecycle Configuration.
StudioLifecycleConfigArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateStudioLifecycleConfigMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateStudioLifecycleConfig{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateStudioLifecycleConfig{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateStudioLifecycleConfigValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateStudioLifecycleConfig(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreateStudioLifecycleConfig(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateStudioLifecycleConfig",
}
}

334
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateTrainingJob.go generated vendored Normal file
View File

@@ -0,0 +1,334 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Starts a model training job. After training completes, Amazon SageMaker saves
// the resulting model artifacts to an Amazon S3 location that you specify. If you
// choose to host your model using Amazon SageMaker hosting services, you can use
// the resulting model artifacts as part of the model. You can also use the
// artifacts in a machine learning service other than Amazon SageMaker, provided
// that you know how to use them for inference. In the request body, you provide
// the following:
//
// * AlgorithmSpecification - Identifies the training algorithm to
// use.
//
// * HyperParameters - Specify these algorithm-specific parameters to enable
// the estimation of model parameters during training. Hyperparameters can be tuned
// to optimize this learning process. For a list of hyperparameters for each
// training algorithm provided by Amazon SageMaker, see Algorithms
// (https://docs.aws.amazon.com/sagemaker/latest/dg/algos.html).
//
// * InputDataConfig
// - Describes the training dataset and the Amazon S3, EFS, or FSx location where
// it is stored.
//
// * OutputDataConfig - Identifies the Amazon S3 bucket where you
// want Amazon SageMaker to save the results of model training.
//
// * ResourceConfig -
// Identifies the resources, ML compute instances, and ML storage volumes to deploy
// for model training. In distributed training, you specify more than one
// instance.
//
// * EnableManagedSpotTraining - Optimize the cost of training machine
// learning models by up to 80% by using Amazon EC2 Spot instances. For more
// information, see Managed Spot Training
// (https://docs.aws.amazon.com/sagemaker/latest/dg/model-managed-spot-training.html).
//
// *
// RoleArn - The Amazon Resource Name (ARN) that Amazon SageMaker assumes to
// perform tasks on your behalf during model training. You must grant this role the
// necessary permissions so that Amazon SageMaker can successfully complete model
// training.
//
// * StoppingCondition - To help cap training costs, use
// MaxRuntimeInSeconds to set a time limit for training. Use MaxWaitTimeInSeconds
// to specify how long a managed spot training job has to complete.
//
// * Environment
// - The environment variables to set in the Docker container.
//
// * RetryStrategy -
// The number of times to retry the job when the job fails due to an
// InternalServerError.
//
// For more information about Amazon SageMaker, see How It
// Works (https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works.html).
func (c *Client) CreateTrainingJob(ctx context.Context, params *CreateTrainingJobInput, optFns ...func(*Options)) (*CreateTrainingJobOutput, error) {
if params == nil {
params = &CreateTrainingJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateTrainingJob", params, optFns, c.addOperationCreateTrainingJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateTrainingJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateTrainingJobInput struct {
// The registry path of the Docker image that contains the training algorithm and
// algorithm-specific metadata, including the input mode. For more information
// about algorithms provided by Amazon SageMaker, see Algorithms
// (https://docs.aws.amazon.com/sagemaker/latest/dg/algos.html). For information
// about providing your own algorithms, see Using Your Own Algorithms with Amazon
// SageMaker
// (https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms.html).
//
// This member is required.
AlgorithmSpecification *types.AlgorithmSpecification
// Specifies the path to the S3 location where you want to store model artifacts.
// Amazon SageMaker creates subfolders for the artifacts.
//
// This member is required.
OutputDataConfig *types.OutputDataConfig
// The resources, including the ML compute instances and ML storage volumes, to use
// for model training. ML storage volumes store model artifacts and incremental
// states. Training algorithms might also use ML storage volumes for scratch space.
// If you want Amazon SageMaker to use the ML storage volume to store the training
// data, choose File as the TrainingInputMode in the algorithm specification. For
// distributed training algorithms, specify an instance count greater than 1.
//
// This member is required.
ResourceConfig *types.ResourceConfig
// The Amazon Resource Name (ARN) of an IAM role that Amazon SageMaker can assume
// to perform tasks on your behalf. During model training, Amazon SageMaker needs
// your permission to read input data from an S3 bucket, download a Docker image
// that contains training code, write model artifacts to an S3 bucket, write logs
// to Amazon CloudWatch Logs, and publish metrics to Amazon CloudWatch. You grant
// permissions for all of these tasks to an IAM role. For more information, see
// Amazon SageMaker Roles
// (https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html). To be
// able to pass this role to Amazon SageMaker, the caller of this API must have the
// iam:PassRole permission.
//
// This member is required.
RoleArn *string
// Specifies a limit to how long a model training job can run. It also specifies
// how long a managed Spot training job has to complete. When the job reaches the
// time limit, Amazon SageMaker ends the training job. Use this API to cap model
// training costs. To stop a job, Amazon SageMaker sends the algorithm the SIGTERM
// signal, which delays job termination for 120 seconds. Algorithms can use this
// 120-second window to save the model artifacts, so the results of training are
// not lost.
//
// This member is required.
StoppingCondition *types.StoppingCondition
// The name of the training job. The name must be unique within an Amazon Web
// Services Region in an Amazon Web Services account.
//
// This member is required.
TrainingJobName *string
// Contains information about the output location for managed spot training
// checkpoint data.
CheckpointConfig *types.CheckpointConfig
// Configuration information for the Debugger hook parameters, metric and tensor
// collections, and storage paths. To learn more about how to configure the
// DebugHookConfig parameter, see Use the SageMaker and Debugger Configuration API
// Operations to Create, Update, and Debug Your Training Job
// (https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-createtrainingjob-api.html).
DebugHookConfig *types.DebugHookConfig
// Configuration information for Debugger rules for debugging output tensors.
DebugRuleConfigurations []types.DebugRuleConfiguration
// To encrypt all communications between ML compute instances in distributed
// training, choose True. Encryption provides greater security for distributed
// training, but training might take longer. How long it takes depends on the
// amount of communication between compute instances, especially if you use a deep
// learning algorithm in distributed training. For more information, see Protect
// Communications Between ML Compute Instances in a Distributed Training Job
// (https://docs.aws.amazon.com/sagemaker/latest/dg/train-encrypt.html).
EnableInterContainerTrafficEncryption bool
// To train models using managed spot training, choose True. Managed spot training
// provides a fully managed and scalable infrastructure for training machine
// learning models. this option is useful when training jobs can be interrupted and
// when there is flexibility when the training job is run. The complete and
// intermediate results of jobs are stored in an Amazon S3 bucket, and can be used
// as a starting point to train models incrementally. Amazon SageMaker provides
// metrics and logs in CloudWatch. They can be used to see when managed spot
// training jobs are running, interrupted, resumed, or completed.
EnableManagedSpotTraining bool
// Isolates the training container. No inbound or outbound network calls can be
// made, except for calls between peers within a training cluster for distributed
// training. If you enable network isolation for training jobs that are configured
// to use a VPC, Amazon SageMaker downloads and uploads customer data and model
// artifacts through the specified VPC, but the training container does not have
// network access.
EnableNetworkIsolation bool
// The environment variables to set in the Docker container.
Environment map[string]string
// Associates a SageMaker job as a trial component with an experiment and trial.
// Specified when you call the following APIs:
//
// * CreateProcessingJob
//
// *
// CreateTrainingJob
//
// * CreateTransformJob
ExperimentConfig *types.ExperimentConfig
// Algorithm-specific parameters that influence the quality of the model. You set
// hyperparameters before you start the learning process. For a list of
// hyperparameters for each training algorithm provided by Amazon SageMaker, see
// Algorithms (https://docs.aws.amazon.com/sagemaker/latest/dg/algos.html). You can
// specify a maximum of 100 hyperparameters. Each hyperparameter is a key-value
// pair. Each key and value is limited to 256 characters, as specified by the
// Length Constraint.
HyperParameters map[string]string
// An array of Channel objects. Each channel is a named input source.
// InputDataConfig describes the input data and its location. Algorithms can accept
// input data from one or more channels. For example, an algorithm might have two
// channels of input data, training_data and validation_data. The configuration for
// each channel provides the S3, EFS, or FSx location where the input data is
// stored. It also provides information about the stored data: the MIME type,
// compression method, and whether the data is wrapped in RecordIO format.
// Depending on the input mode that the algorithm supports, Amazon SageMaker either
// copies input data files from an S3 bucket to a local directory in the Docker
// container, or makes it available as input streams. For example, if you specify
// an EFS location, input data files will be made available as input streams. They
// do not need to be downloaded.
InputDataConfig []types.Channel
// Configuration information for Debugger system monitoring, framework profiling,
// and storage paths.
ProfilerConfig *types.ProfilerConfig
// Configuration information for Debugger rules for profiling system and framework
// metrics.
ProfilerRuleConfigurations []types.ProfilerRuleConfiguration
// The number of times to retry the job when the job fails due to an
// InternalServerError.
RetryStrategy *types.RetryStrategy
// An array of key-value pairs. You can use tags to categorize your Amazon Web
// Services resources in different ways, for example, by purpose, owner, or
// environment. For more information, see Tagging Amazon Web Services Resources
// (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html).
Tags []types.Tag
// Configuration of storage locations for the Debugger TensorBoard output data.
TensorBoardOutputConfig *types.TensorBoardOutputConfig
// A VpcConfig object that specifies the VPC that you want your training job to
// connect to. Control access to and from your training container by configuring
// the VPC. For more information, see Protect Training Jobs by Using an Amazon
// Virtual Private Cloud
// (https://docs.aws.amazon.com/sagemaker/latest/dg/train-vpc.html).
VpcConfig *types.VpcConfig
noSmithyDocumentSerde
}
type CreateTrainingJobOutput struct {
// The Amazon Resource Name (ARN) of the training job.
//
// This member is required.
TrainingJobArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateTrainingJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateTrainingJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateTrainingJob{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateTrainingJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateTrainingJob(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreateTrainingJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateTrainingJob",
}
}

241
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateTransformJob.go generated vendored Normal file
View File

@@ -0,0 +1,241 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Starts a transform job. A transform job uses a trained model to get inferences
// on a dataset and saves these results to an Amazon S3 location that you specify.
// To perform batch transformations, you create a transform job and use the data
// that you have readily available. In the request body, you provide the
// following:
//
// * TransformJobName - Identifies the transform job. The name must be
// unique within an Amazon Web Services Region in an Amazon Web Services
// account.
//
// * ModelName - Identifies the model to use. ModelName must be the name
// of an existing Amazon SageMaker model in the same Amazon Web Services Region and
// Amazon Web Services account. For information on creating a model, see
// CreateModel.
//
// * TransformInput - Describes the dataset to be transformed and the
// Amazon S3 location where it is stored.
//
// * TransformOutput - Identifies the
// Amazon S3 location where you want Amazon SageMaker to save the results from the
// transform job.
//
// * TransformResources - Identifies the ML compute instances for
// the transform job.
//
// For more information about how batch transformation works,
// see Batch Transform
// (https://docs.aws.amazon.com/sagemaker/latest/dg/batch-transform.html).
func (c *Client) CreateTransformJob(ctx context.Context, params *CreateTransformJobInput, optFns ...func(*Options)) (*CreateTransformJobOutput, error) {
if params == nil {
params = &CreateTransformJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateTransformJob", params, optFns, c.addOperationCreateTransformJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateTransformJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateTransformJobInput struct {
// The name of the model that you want to use for the transform job. ModelName must
// be the name of an existing Amazon SageMaker model within an Amazon Web Services
// Region in an Amazon Web Services account.
//
// This member is required.
ModelName *string
// Describes the input source and the way the transform job consumes it.
//
// This member is required.
TransformInput *types.TransformInput
// The name of the transform job. The name must be unique within an Amazon Web
// Services Region in an Amazon Web Services account.
//
// This member is required.
TransformJobName *string
// Describes the results of the transform job.
//
// This member is required.
TransformOutput *types.TransformOutput
// Describes the resources, including ML instance types and ML instance count, to
// use for the transform job.
//
// This member is required.
TransformResources *types.TransformResources
// Specifies the number of records to include in a mini-batch for an HTTP inference
// request. A record is a single unit of input data that inference can be made on.
// For example, a single line in a CSV file is a record. To enable the batch
// strategy, you must set the SplitType property to Line, RecordIO, or TFRecord. To
// use only one record when making an HTTP invocation request to a container, set
// BatchStrategy to SingleRecord and SplitType to Line. To fit as many records in a
// mini-batch as can fit within the MaxPayloadInMB limit, set BatchStrategy to
// MultiRecord and SplitType to Line.
BatchStrategy types.BatchStrategy
// The data structure used to specify the data to be used for inference in a batch
// transform job and to associate the data that is relevant to the prediction
// results in the output. The input filter provided allows you to exclude input
// data that is not needed for inference in a batch transform job. The output
// filter provided allows you to include input data relevant to interpreting the
// predictions in the output from the job. For more information, see Associate
// Prediction Results with their Corresponding Input Records
// (https://docs.aws.amazon.com/sagemaker/latest/dg/batch-transform-data-processing.html).
DataProcessing *types.DataProcessing
// The environment variables to set in the Docker container. We support up to 16
// key and values entries in the map.
Environment map[string]string
// Associates a SageMaker job as a trial component with an experiment and trial.
// Specified when you call the following APIs:
//
// * CreateProcessingJob
//
// *
// CreateTrainingJob
//
// * CreateTransformJob
ExperimentConfig *types.ExperimentConfig
// The maximum number of parallel requests that can be sent to each instance in a
// transform job. If MaxConcurrentTransforms is set to 0 or left unset, Amazon
// SageMaker checks the optional execution-parameters to determine the settings for
// your chosen algorithm. If the execution-parameters endpoint is not enabled, the
// default value is 1. For more information on execution-parameters, see How
// Containers Serve Requests
// (https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-batch-code.html#your-algorithms-batch-code-how-containe-serves-requests).
// For built-in algorithms, you don't need to set a value for
// MaxConcurrentTransforms.
MaxConcurrentTransforms *int32
// The maximum allowed size of the payload, in MB. A payload is the data portion of
// a record (without metadata). The value in MaxPayloadInMB must be greater than,
// or equal to, the size of a single record. To estimate the size of a record in
// MB, divide the size of your dataset by the number of records. To ensure that the
// records fit within the maximum payload size, we recommend using a slightly
// larger value. The default value is 6 MB. For cases where the payload might be
// arbitrarily large and is transmitted using HTTP chunked encoding, set the value
// to 0. This feature works only in supported algorithms. Currently, Amazon
// SageMaker built-in algorithms do not support HTTP chunked encoding.
MaxPayloadInMB *int32
// Configures the timeout and maximum number of retries for processing a transform
// job invocation.
ModelClientConfig *types.ModelClientConfig
// (Optional) An array of key-value pairs. For more information, see Using Cost
// Allocation Tags
// (https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html#allocation-what)
// in the Amazon Web Services Billing and Cost Management User Guide.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateTransformJobOutput struct {
// The Amazon Resource Name (ARN) of the transform job.
//
// This member is required.
TransformJobArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateTransformJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateTransformJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateTransformJob{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateTransformJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateTransformJob(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreateTransformJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateTransformJob",
}
}

146
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateTrial.go generated vendored Normal file
View File

@@ -0,0 +1,146 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates an SageMaker trial. A trial is a set of steps called trial components
// that produce a machine learning model. A trial is part of a single SageMaker
// experiment. When you use SageMaker Studio or the SageMaker Python SDK, all
// experiments, trials, and trial components are automatically tracked, logged, and
// indexed. When you use the Amazon Web Services SDK for Python (Boto), you must
// use the logging APIs provided by the SDK. You can add tags to a trial and then
// use the Search API to search for the tags. To get a list of all your trials,
// call the ListTrials API. To view a trial's properties, call the DescribeTrial
// API. To create a trial component, call the CreateTrialComponent API.
func (c *Client) CreateTrial(ctx context.Context, params *CreateTrialInput, optFns ...func(*Options)) (*CreateTrialOutput, error) {
if params == nil {
params = &CreateTrialInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateTrial", params, optFns, c.addOperationCreateTrialMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateTrialOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateTrialInput struct {
// The name of the experiment to associate the trial with.
//
// This member is required.
ExperimentName *string
// The name of the trial. The name must be unique in your Amazon Web Services
// account and is not case-sensitive.
//
// This member is required.
TrialName *string
// The name of the trial as displayed. The name doesn't need to be unique. If
// DisplayName isn't specified, TrialName is displayed.
DisplayName *string
// Metadata properties of the tracking entity, trial, or trial component.
MetadataProperties *types.MetadataProperties
// A list of tags to associate with the trial. You can use Search API to search on
// the tags.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateTrialOutput struct {
// The Amazon Resource Name (ARN) of the trial.
TrialArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateTrialMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateTrial{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateTrial{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateTrialValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateTrial(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreateTrial(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateTrial",
}
}

168
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateTrialComponent.go generated vendored Normal file
View File

@@ -0,0 +1,168 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Creates a trial component, which is a stage of a machine learning trial. A trial
// is composed of one or more trial components. A trial component can be used in
// multiple trials. Trial components include pre-processing jobs, training jobs,
// and batch transform jobs. When you use SageMaker Studio or the SageMaker Python
// SDK, all experiments, trials, and trial components are automatically tracked,
// logged, and indexed. When you use the Amazon Web Services SDK for Python (Boto),
// you must use the logging APIs provided by the SDK. You can add tags to a trial
// component and then use the Search API to search for the tags.
func (c *Client) CreateTrialComponent(ctx context.Context, params *CreateTrialComponentInput, optFns ...func(*Options)) (*CreateTrialComponentOutput, error) {
if params == nil {
params = &CreateTrialComponentInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateTrialComponent", params, optFns, c.addOperationCreateTrialComponentMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateTrialComponentOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateTrialComponentInput struct {
// The name of the component. The name must be unique in your Amazon Web Services
// account and is not case-sensitive.
//
// This member is required.
TrialComponentName *string
// The name of the component as displayed. The name doesn't need to be unique. If
// DisplayName isn't specified, TrialComponentName is displayed.
DisplayName *string
// When the component ended.
EndTime *time.Time
// The input artifacts for the component. Examples of input artifacts are datasets,
// algorithms, hyperparameters, source code, and instance types.
InputArtifacts map[string]types.TrialComponentArtifact
// Metadata properties of the tracking entity, trial, or trial component.
MetadataProperties *types.MetadataProperties
// The output artifacts for the component. Examples of output artifacts are
// metrics, snapshots, logs, and images.
OutputArtifacts map[string]types.TrialComponentArtifact
// The hyperparameters for the component.
Parameters map[string]types.TrialComponentParameterValue
// When the component started.
StartTime *time.Time
// The status of the component. States include:
//
// * InProgress
//
// * Completed
//
// *
// Failed
Status *types.TrialComponentStatus
// A list of tags to associate with the component. You can use Search API to search
// on the tags.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateTrialComponentOutput struct {
// The Amazon Resource Name (ARN) of the trial component.
TrialComponentArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateTrialComponentMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateTrialComponent{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateTrialComponent{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateTrialComponentValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateTrialComponent(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreateTrialComponent(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateTrialComponent",
}
}

152
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateUserProfile.go generated vendored Normal file
View File

@@ -0,0 +1,152 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a user profile. A user profile represents a single user within a domain,
// and is the main way to reference a "person" for the purposes of sharing,
// reporting, and other user-oriented features. This entity is created when a user
// onboards to Amazon SageMaker Studio. If an administrator invites a person by
// email or imports them from SSO, a user profile is automatically created. A user
// profile is the primary holder of settings for an individual user and has a
// reference to the user's private Amazon Elastic File System (EFS) home directory.
func (c *Client) CreateUserProfile(ctx context.Context, params *CreateUserProfileInput, optFns ...func(*Options)) (*CreateUserProfileOutput, error) {
if params == nil {
params = &CreateUserProfileInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateUserProfile", params, optFns, c.addOperationCreateUserProfileMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateUserProfileOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateUserProfileInput struct {
// The ID of the associated Domain.
//
// This member is required.
DomainId *string
// A name for the UserProfile. This value is not case sensitive.
//
// This member is required.
UserProfileName *string
// A specifier for the type of value specified in SingleSignOnUserValue. Currently,
// the only supported value is "UserName". If the Domain's AuthMode is SSO, this
// field is required. If the Domain's AuthMode is not SSO, this field cannot be
// specified.
SingleSignOnUserIdentifier *string
// The username of the associated Amazon Web Services Single Sign-On User for this
// UserProfile. If the Domain's AuthMode is SSO, this field is required, and must
// match a valid username of a user in your directory. If the Domain's AuthMode is
// not SSO, this field cannot be specified.
SingleSignOnUserValue *string
// Each tag consists of a key and an optional value. Tag keys must be unique per
// resource. Tags that you specify for the User Profile are also added to all Apps
// that the User Profile launches.
Tags []types.Tag
// A collection of settings.
UserSettings *types.UserSettings
noSmithyDocumentSerde
}
type CreateUserProfileOutput struct {
// The user profile Amazon Resource Name (ARN).
UserProfileArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateUserProfileMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateUserProfile{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateUserProfile{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateUserProfileValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateUserProfile(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreateUserProfile(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateUserProfile",
}
}

161
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateWorkforce.go generated vendored Normal file
View File

@@ -0,0 +1,161 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Use this operation to create a workforce. This operation will return an error if
// a workforce already exists in the Amazon Web Services Region that you specify.
// You can only create one workforce in each Amazon Web Services Region per Amazon
// Web Services account. If you want to create a new workforce in an Amazon Web
// Services Region where a workforce already exists, use the API operation to
// delete the existing workforce and then use CreateWorkforce to create a new
// workforce. To create a private workforce using Amazon Cognito, you must specify
// a Cognito user pool in CognitoConfig. You can also create an Amazon Cognito
// workforce using the Amazon SageMaker console. For more information, see Create
// a Private Workforce (Amazon Cognito)
// (https://docs.aws.amazon.com/sagemaker/latest/dg/sms-workforce-create-private.html).
// To create a private workforce using your own OIDC Identity Provider (IdP),
// specify your IdP configuration in OidcConfig. Your OIDC IdP must support groups
// because groups are used by Ground Truth and Amazon A2I to create work teams. For
// more information, see Create a Private Workforce (OIDC IdP)
// (https://docs.aws.amazon.com/sagemaker/latest/dg/sms-workforce-create-private-oidc.html).
func (c *Client) CreateWorkforce(ctx context.Context, params *CreateWorkforceInput, optFns ...func(*Options)) (*CreateWorkforceOutput, error) {
if params == nil {
params = &CreateWorkforceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateWorkforce", params, optFns, c.addOperationCreateWorkforceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateWorkforceOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateWorkforceInput struct {
// The name of the private workforce.
//
// This member is required.
WorkforceName *string
// Use this parameter to configure an Amazon Cognito private workforce. A single
// Cognito workforce is created using and corresponds to a single Amazon Cognito
// user pool
// (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools.html).
// Do not use OidcConfig if you specify values for CognitoConfig.
CognitoConfig *types.CognitoConfig
// Use this parameter to configure a private workforce using your own OIDC Identity
// Provider. Do not use CognitoConfig if you specify values for OidcConfig.
OidcConfig *types.OidcConfig
// A list of IP address ranges (CIDRs
// (https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Subnets.html)). Used to
// create an allow list of IP addresses for a private workforce. Workers will only
// be able to login to their worker portal from an IP address within this range. By
// default, a workforce isn't restricted to specific IP addresses.
SourceIpConfig *types.SourceIpConfig
// An array of key-value pairs that contain metadata to help you categorize and
// organize our workforce. Each tag consists of a key and a value, both of which
// you define.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateWorkforceOutput struct {
// The Amazon Resource Name (ARN) of the workforce.
//
// This member is required.
WorkforceArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateWorkforceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateWorkforce{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateWorkforce{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateWorkforceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateWorkforce(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreateWorkforce(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateWorkforce",
}
}

163
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_CreateWorkteam.go generated vendored Normal file
View File

@@ -0,0 +1,163 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Creates a new work team for labeling your data. A work team is defined by one or
// more Amazon Cognito user pools. You must first create the user pools before you
// can create a work team. You cannot create more than 25 work teams in an account
// and region.
func (c *Client) CreateWorkteam(ctx context.Context, params *CreateWorkteamInput, optFns ...func(*Options)) (*CreateWorkteamOutput, error) {
if params == nil {
params = &CreateWorkteamInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateWorkteam", params, optFns, c.addOperationCreateWorkteamMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateWorkteamOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateWorkteamInput struct {
// A description of the work team.
//
// This member is required.
Description *string
// A list of MemberDefinition objects that contains objects that identify the
// workers that make up the work team. Workforces can be created using Amazon
// Cognito or your own OIDC Identity Provider (IdP). For private workforces created
// using Amazon Cognito use CognitoMemberDefinition. For workforces created using
// your own OIDC identity provider (IdP) use OidcMemberDefinition. Do not provide
// input for both of these parameters in a single request. For workforces created
// using Amazon Cognito, private work teams correspond to Amazon Cognito user
// groups within the user pool used to create a workforce. All of the
// CognitoMemberDefinition objects that make up the member definition must have the
// same ClientId and UserPool values. To add a Amazon Cognito user group to an
// existing worker pool, see Adding groups to a User Pool. For more information
// about user pools, see Amazon Cognito User Pools
// (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools.html).
// For workforces created using your own OIDC IdP, specify the user groups that you
// want to include in your private work team in OidcMemberDefinition by listing
// those groups in Groups.
//
// This member is required.
MemberDefinitions []types.MemberDefinition
// The name of the work team. Use this name to identify the work team.
//
// This member is required.
WorkteamName *string
// Configures notification of workers regarding available or expiring work items.
NotificationConfiguration *types.NotificationConfiguration
// An array of key-value pairs. For more information, see Resource Tag
// (https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-resource-tags.html)
// and Using Cost Allocation Tags
// (https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html#allocation-what)
// in the Amazon Web Services Billing and Cost Management User Guide.
Tags []types.Tag
// The name of the workforce.
WorkforceName *string
noSmithyDocumentSerde
}
type CreateWorkteamOutput struct {
// The Amazon Resource Name (ARN) of the work team. You can use this ARN to
// identify the work team.
WorkteamArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateWorkteamMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateWorkteam{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateWorkteam{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpCreateWorkteamValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateWorkteam(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opCreateWorkteam(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateWorkteam",
}
}

120
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DeleteAction.go generated vendored Normal file
View File

@@ -0,0 +1,120 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes an action.
func (c *Client) DeleteAction(ctx context.Context, params *DeleteActionInput, optFns ...func(*Options)) (*DeleteActionOutput, error) {
if params == nil {
params = &DeleteActionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteAction", params, optFns, c.addOperationDeleteActionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteActionOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteActionInput struct {
// The name of the action to delete.
//
// This member is required.
ActionName *string
noSmithyDocumentSerde
}
type DeleteActionOutput struct {
// The Amazon Resource Name (ARN) of the action.
ActionArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteActionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteAction{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteAction{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteActionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteAction(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDeleteAction(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteAction",
}
}

116
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DeleteAlgorithm.go generated vendored Normal file
View File

@@ -0,0 +1,116 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Removes the specified algorithm from your account.
func (c *Client) DeleteAlgorithm(ctx context.Context, params *DeleteAlgorithmInput, optFns ...func(*Options)) (*DeleteAlgorithmOutput, error) {
if params == nil {
params = &DeleteAlgorithmInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteAlgorithm", params, optFns, c.addOperationDeleteAlgorithmMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteAlgorithmOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteAlgorithmInput struct {
// The name of the algorithm to delete.
//
// This member is required.
AlgorithmName *string
noSmithyDocumentSerde
}
type DeleteAlgorithmOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteAlgorithmMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteAlgorithm{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteAlgorithm{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteAlgorithmValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteAlgorithm(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDeleteAlgorithm(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteAlgorithm",
}
}

132
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DeleteApp.go generated vendored Normal file
View File

@@ -0,0 +1,132 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Used to stop and delete an app.
func (c *Client) DeleteApp(ctx context.Context, params *DeleteAppInput, optFns ...func(*Options)) (*DeleteAppOutput, error) {
if params == nil {
params = &DeleteAppInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteApp", params, optFns, c.addOperationDeleteAppMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteAppOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteAppInput struct {
// The name of the app.
//
// This member is required.
AppName *string
// The type of app.
//
// This member is required.
AppType types.AppType
// The domain ID.
//
// This member is required.
DomainId *string
// The user profile name.
//
// This member is required.
UserProfileName *string
noSmithyDocumentSerde
}
type DeleteAppOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteAppMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteApp{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteApp{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteAppValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteApp(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDeleteApp(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteApp",
}
}

116
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DeleteAppImageConfig.go generated vendored Normal file
View File

@@ -0,0 +1,116 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes an AppImageConfig.
func (c *Client) DeleteAppImageConfig(ctx context.Context, params *DeleteAppImageConfigInput, optFns ...func(*Options)) (*DeleteAppImageConfigOutput, error) {
if params == nil {
params = &DeleteAppImageConfigInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteAppImageConfig", params, optFns, c.addOperationDeleteAppImageConfigMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteAppImageConfigOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteAppImageConfigInput struct {
// The name of the AppImageConfig to delete.
//
// This member is required.
AppImageConfigName *string
noSmithyDocumentSerde
}
type DeleteAppImageConfigOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteAppImageConfigMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteAppImageConfig{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteAppImageConfig{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteAppImageConfigValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteAppImageConfig(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDeleteAppImageConfig(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteAppImageConfig",
}
}

122
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DeleteArtifact.go generated vendored Normal file
View File

@@ -0,0 +1,122 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes an artifact. Either ArtifactArn or Source must be specified.
func (c *Client) DeleteArtifact(ctx context.Context, params *DeleteArtifactInput, optFns ...func(*Options)) (*DeleteArtifactOutput, error) {
if params == nil {
params = &DeleteArtifactInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteArtifact", params, optFns, c.addOperationDeleteArtifactMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteArtifactOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteArtifactInput struct {
// The Amazon Resource Name (ARN) of the artifact to delete.
ArtifactArn *string
// The URI of the source.
Source *types.ArtifactSource
noSmithyDocumentSerde
}
type DeleteArtifactOutput struct {
// The Amazon Resource Name (ARN) of the artifact.
ArtifactArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteArtifactMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteArtifact{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteArtifact{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteArtifactValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteArtifact(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDeleteArtifact(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteArtifact",
}
}

128
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DeleteAssociation.go generated vendored Normal file
View File

@@ -0,0 +1,128 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes an association.
func (c *Client) DeleteAssociation(ctx context.Context, params *DeleteAssociationInput, optFns ...func(*Options)) (*DeleteAssociationOutput, error) {
if params == nil {
params = &DeleteAssociationInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteAssociation", params, optFns, c.addOperationDeleteAssociationMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteAssociationOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteAssociationInput struct {
// The Amazon Resource Name (ARN) of the destination.
//
// This member is required.
DestinationArn *string
// The ARN of the source.
//
// This member is required.
SourceArn *string
noSmithyDocumentSerde
}
type DeleteAssociationOutput struct {
// The Amazon Resource Name (ARN) of the destination.
DestinationArn *string
// The ARN of the source.
SourceArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteAssociationMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteAssociation{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteAssociation{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteAssociationValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteAssociation(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDeleteAssociation(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteAssociation",
}
}

116
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DeleteCodeRepository.go generated vendored Normal file
View File

@@ -0,0 +1,116 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes the specified Git repository from your account.
func (c *Client) DeleteCodeRepository(ctx context.Context, params *DeleteCodeRepositoryInput, optFns ...func(*Options)) (*DeleteCodeRepositoryOutput, error) {
if params == nil {
params = &DeleteCodeRepositoryInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteCodeRepository", params, optFns, c.addOperationDeleteCodeRepositoryMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteCodeRepositoryOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteCodeRepositoryInput struct {
// The name of the Git repository to delete.
//
// This member is required.
CodeRepositoryName *string
noSmithyDocumentSerde
}
type DeleteCodeRepositoryOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteCodeRepositoryMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteCodeRepository{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteCodeRepository{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteCodeRepositoryValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteCodeRepository(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDeleteCodeRepository(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteCodeRepository",
}
}

120
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DeleteContext.go generated vendored Normal file
View File

@@ -0,0 +1,120 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes an context.
func (c *Client) DeleteContext(ctx context.Context, params *DeleteContextInput, optFns ...func(*Options)) (*DeleteContextOutput, error) {
if params == nil {
params = &DeleteContextInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteContext", params, optFns, c.addOperationDeleteContextMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteContextOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteContextInput struct {
// The name of the context to delete.
//
// This member is required.
ContextName *string
noSmithyDocumentSerde
}
type DeleteContextOutput struct {
// The Amazon Resource Name (ARN) of the context.
ContextArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteContextMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteContext{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteContext{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteContextValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteContext(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDeleteContext(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteContext",
}
}

116
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DeleteDataQualityJobDefinition.go generated vendored Normal file
View File

@@ -0,0 +1,116 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a data quality monitoring job definition.
func (c *Client) DeleteDataQualityJobDefinition(ctx context.Context, params *DeleteDataQualityJobDefinitionInput, optFns ...func(*Options)) (*DeleteDataQualityJobDefinitionOutput, error) {
if params == nil {
params = &DeleteDataQualityJobDefinitionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteDataQualityJobDefinition", params, optFns, c.addOperationDeleteDataQualityJobDefinitionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteDataQualityJobDefinitionOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteDataQualityJobDefinitionInput struct {
// The name of the data quality monitoring job definition to delete.
//
// This member is required.
JobDefinitionName *string
noSmithyDocumentSerde
}
type DeleteDataQualityJobDefinitionOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteDataQualityJobDefinitionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteDataQualityJobDefinition{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteDataQualityJobDefinition{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteDataQualityJobDefinitionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteDataQualityJobDefinition(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDeleteDataQualityJobDefinition(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteDataQualityJobDefinition",
}
}

116
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DeleteDeviceFleet.go generated vendored Normal file
View File

@@ -0,0 +1,116 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a fleet.
func (c *Client) DeleteDeviceFleet(ctx context.Context, params *DeleteDeviceFleetInput, optFns ...func(*Options)) (*DeleteDeviceFleetOutput, error) {
if params == nil {
params = &DeleteDeviceFleetInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteDeviceFleet", params, optFns, c.addOperationDeleteDeviceFleetMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteDeviceFleetOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteDeviceFleetInput struct {
// The name of the fleet to delete.
//
// This member is required.
DeviceFleetName *string
noSmithyDocumentSerde
}
type DeleteDeviceFleetOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteDeviceFleetMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteDeviceFleet{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteDeviceFleet{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteDeviceFleetValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteDeviceFleet(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDeleteDeviceFleet(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteDeviceFleet",
}
}

125
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DeleteDomain.go generated vendored Normal file
View File

@@ -0,0 +1,125 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Used to delete a domain. If you onboarded with IAM mode, you will need to delete
// your domain to onboard again using SSO. Use with caution. All of the members of
// the domain will lose access to their EFS volume, including data, notebooks, and
// other artifacts.
func (c *Client) DeleteDomain(ctx context.Context, params *DeleteDomainInput, optFns ...func(*Options)) (*DeleteDomainOutput, error) {
if params == nil {
params = &DeleteDomainInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteDomain", params, optFns, c.addOperationDeleteDomainMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteDomainOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteDomainInput struct {
// The domain ID.
//
// This member is required.
DomainId *string
// The retention policy for this domain, which specifies whether resources will be
// retained after the Domain is deleted. By default, all resources are retained
// (not automatically deleted).
RetentionPolicy *types.RetentionPolicy
noSmithyDocumentSerde
}
type DeleteDomainOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteDomainMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteDomain{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteDomain{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteDomainValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteDomain(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDeleteDomain(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteDomain",
}
}

121
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DeleteEndpoint.go generated vendored Normal file
View File

@@ -0,0 +1,121 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes an endpoint. Amazon SageMaker frees up all of the resources that were
// deployed when the endpoint was created. Amazon SageMaker retires any custom KMS
// key grants associated with the endpoint, meaning you don't need to use the
// RevokeGrant
// (http://docs.aws.amazon.com/kms/latest/APIReference/API_RevokeGrant.html) API
// call.
func (c *Client) DeleteEndpoint(ctx context.Context, params *DeleteEndpointInput, optFns ...func(*Options)) (*DeleteEndpointOutput, error) {
if params == nil {
params = &DeleteEndpointInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteEndpoint", params, optFns, c.addOperationDeleteEndpointMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteEndpointOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteEndpointInput struct {
// The name of the endpoint that you want to delete.
//
// This member is required.
EndpointName *string
noSmithyDocumentSerde
}
type DeleteEndpointOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteEndpointMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteEndpoint{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteEndpoint{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteEndpointValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteEndpoint(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDeleteEndpoint(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteEndpoint",
}
}

123
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DeleteEndpointConfig.go generated vendored Normal file
View File

@@ -0,0 +1,123 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes an endpoint configuration. The DeleteEndpointConfig API deletes only the
// specified configuration. It does not delete endpoints created using the
// configuration. You must not delete an EndpointConfig in use by an endpoint that
// is live or while the UpdateEndpoint or CreateEndpoint operations are being
// performed on the endpoint. If you delete the EndpointConfig of an endpoint that
// is active or being created or updated you may lose visibility into the instance
// type the endpoint is using. The endpoint must be deleted in order to stop
// incurring charges.
func (c *Client) DeleteEndpointConfig(ctx context.Context, params *DeleteEndpointConfigInput, optFns ...func(*Options)) (*DeleteEndpointConfigOutput, error) {
if params == nil {
params = &DeleteEndpointConfigInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteEndpointConfig", params, optFns, c.addOperationDeleteEndpointConfigMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteEndpointConfigOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteEndpointConfigInput struct {
// The name of the endpoint configuration that you want to delete.
//
// This member is required.
EndpointConfigName *string
noSmithyDocumentSerde
}
type DeleteEndpointConfigOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteEndpointConfigMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteEndpointConfig{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteEndpointConfig{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteEndpointConfigValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteEndpointConfig(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDeleteEndpointConfig(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteEndpointConfig",
}
}

122
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DeleteExperiment.go generated vendored Normal file
View File

@@ -0,0 +1,122 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes an SageMaker experiment. All trials associated with the experiment must
// be deleted first. Use the ListTrials API to get a list of the trials associated
// with the experiment.
func (c *Client) DeleteExperiment(ctx context.Context, params *DeleteExperimentInput, optFns ...func(*Options)) (*DeleteExperimentOutput, error) {
if params == nil {
params = &DeleteExperimentInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteExperiment", params, optFns, c.addOperationDeleteExperimentMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteExperimentOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteExperimentInput struct {
// The name of the experiment to delete.
//
// This member is required.
ExperimentName *string
noSmithyDocumentSerde
}
type DeleteExperimentOutput struct {
// The Amazon Resource Name (ARN) of the experiment that is being deleted.
ExperimentArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteExperimentMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteExperiment{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteExperiment{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteExperimentValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteExperiment(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDeleteExperiment(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteExperiment",
}
}

121
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DeleteFeatureGroup.go generated vendored Normal file
View File

@@ -0,0 +1,121 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Delete the FeatureGroup and any data that was written to the OnlineStore of the
// FeatureGroup. Data cannot be accessed from the OnlineStore immediately after
// DeleteFeatureGroup is called. Data written into the OfflineStore will not be
// deleted. The Amazon Web Services Glue database and tables that are automatically
// created for your OfflineStore are not deleted.
func (c *Client) DeleteFeatureGroup(ctx context.Context, params *DeleteFeatureGroupInput, optFns ...func(*Options)) (*DeleteFeatureGroupOutput, error) {
if params == nil {
params = &DeleteFeatureGroupInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteFeatureGroup", params, optFns, c.addOperationDeleteFeatureGroupMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteFeatureGroupOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteFeatureGroupInput struct {
// The name of the FeatureGroup you want to delete. The name must be unique within
// an Amazon Web Services Region in an Amazon Web Services account.
//
// This member is required.
FeatureGroupName *string
noSmithyDocumentSerde
}
type DeleteFeatureGroupOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteFeatureGroupMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteFeatureGroup{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteFeatureGroup{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteFeatureGroupValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteFeatureGroup(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDeleteFeatureGroup(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteFeatureGroup",
}
}

116
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DeleteFlowDefinition.go generated vendored Normal file
View File

@@ -0,0 +1,116 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes the specified flow definition.
func (c *Client) DeleteFlowDefinition(ctx context.Context, params *DeleteFlowDefinitionInput, optFns ...func(*Options)) (*DeleteFlowDefinitionOutput, error) {
if params == nil {
params = &DeleteFlowDefinitionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteFlowDefinition", params, optFns, c.addOperationDeleteFlowDefinitionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteFlowDefinitionOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteFlowDefinitionInput struct {
// The name of the flow definition you are deleting.
//
// This member is required.
FlowDefinitionName *string
noSmithyDocumentSerde
}
type DeleteFlowDefinitionOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteFlowDefinitionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteFlowDefinition{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteFlowDefinition{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteFlowDefinitionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteFlowDefinition(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDeleteFlowDefinition(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteFlowDefinition",
}
}

120
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DeleteHumanTaskUi.go generated vendored Normal file
View File

@@ -0,0 +1,120 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Use this operation to delete a human task user interface (worker task template).
// To see a list of human task user interfaces (work task templates) in your
// account, use . When you delete a worker task template, it no longer appears when
// you call ListHumanTaskUis.
func (c *Client) DeleteHumanTaskUi(ctx context.Context, params *DeleteHumanTaskUiInput, optFns ...func(*Options)) (*DeleteHumanTaskUiOutput, error) {
if params == nil {
params = &DeleteHumanTaskUiInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteHumanTaskUi", params, optFns, c.addOperationDeleteHumanTaskUiMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteHumanTaskUiOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteHumanTaskUiInput struct {
// The name of the human task user interface (work task template) you want to
// delete.
//
// This member is required.
HumanTaskUiName *string
noSmithyDocumentSerde
}
type DeleteHumanTaskUiOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteHumanTaskUiMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteHumanTaskUi{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteHumanTaskUi{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteHumanTaskUiValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteHumanTaskUi(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDeleteHumanTaskUi(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteHumanTaskUi",
}
}

117
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DeleteImage.go generated vendored Normal file
View File

@@ -0,0 +1,117 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a SageMaker image and all versions of the image. The container images
// aren't deleted.
func (c *Client) DeleteImage(ctx context.Context, params *DeleteImageInput, optFns ...func(*Options)) (*DeleteImageOutput, error) {
if params == nil {
params = &DeleteImageInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteImage", params, optFns, c.addOperationDeleteImageMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteImageOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteImageInput struct {
// The name of the image to delete.
//
// This member is required.
ImageName *string
noSmithyDocumentSerde
}
type DeleteImageOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteImageMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteImage{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteImage{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteImageValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteImage(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDeleteImage(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteImage",
}
}

122
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DeleteImageVersion.go generated vendored Normal file
View File

@@ -0,0 +1,122 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a version of a SageMaker image. The container image the version
// represents isn't deleted.
func (c *Client) DeleteImageVersion(ctx context.Context, params *DeleteImageVersionInput, optFns ...func(*Options)) (*DeleteImageVersionOutput, error) {
if params == nil {
params = &DeleteImageVersionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteImageVersion", params, optFns, c.addOperationDeleteImageVersionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteImageVersionOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteImageVersionInput struct {
// The name of the image.
//
// This member is required.
ImageName *string
// The version to delete.
//
// This member is required.
Version *int32
noSmithyDocumentSerde
}
type DeleteImageVersionOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteImageVersionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteImageVersion{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteImageVersion{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteImageVersionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteImageVersion(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDeleteImageVersion(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteImageVersion",
}
}

119
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DeleteModel.go generated vendored Normal file
View File

@@ -0,0 +1,119 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a model. The DeleteModel API deletes only the model entry that was
// created in Amazon SageMaker when you called the CreateModel API. It does not
// delete model artifacts, inference code, or the IAM role that you specified when
// creating the model.
func (c *Client) DeleteModel(ctx context.Context, params *DeleteModelInput, optFns ...func(*Options)) (*DeleteModelOutput, error) {
if params == nil {
params = &DeleteModelInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteModel", params, optFns, c.addOperationDeleteModelMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteModelOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteModelInput struct {
// The name of the model to delete.
//
// This member is required.
ModelName *string
noSmithyDocumentSerde
}
type DeleteModelOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteModelMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteModel{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteModel{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteModelValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteModel(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDeleteModel(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteModel",
}
}

116
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DeleteModelBiasJobDefinition.go generated vendored Normal file
View File

@@ -0,0 +1,116 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes an Amazon SageMaker model bias job definition.
func (c *Client) DeleteModelBiasJobDefinition(ctx context.Context, params *DeleteModelBiasJobDefinitionInput, optFns ...func(*Options)) (*DeleteModelBiasJobDefinitionOutput, error) {
if params == nil {
params = &DeleteModelBiasJobDefinitionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteModelBiasJobDefinition", params, optFns, c.addOperationDeleteModelBiasJobDefinitionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteModelBiasJobDefinitionOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteModelBiasJobDefinitionInput struct {
// The name of the model bias job definition to delete.
//
// This member is required.
JobDefinitionName *string
noSmithyDocumentSerde
}
type DeleteModelBiasJobDefinitionOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteModelBiasJobDefinitionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteModelBiasJobDefinition{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteModelBiasJobDefinition{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteModelBiasJobDefinitionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteModelBiasJobDefinition(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDeleteModelBiasJobDefinition(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteModelBiasJobDefinition",
}
}

116
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DeleteModelExplainabilityJobDefinition.go generated vendored Normal file
View File

@@ -0,0 +1,116 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes an Amazon SageMaker model explainability job definition.
func (c *Client) DeleteModelExplainabilityJobDefinition(ctx context.Context, params *DeleteModelExplainabilityJobDefinitionInput, optFns ...func(*Options)) (*DeleteModelExplainabilityJobDefinitionOutput, error) {
if params == nil {
params = &DeleteModelExplainabilityJobDefinitionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteModelExplainabilityJobDefinition", params, optFns, c.addOperationDeleteModelExplainabilityJobDefinitionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteModelExplainabilityJobDefinitionOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteModelExplainabilityJobDefinitionInput struct {
// The name of the model explainability job definition to delete.
//
// This member is required.
JobDefinitionName *string
noSmithyDocumentSerde
}
type DeleteModelExplainabilityJobDefinitionOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteModelExplainabilityJobDefinitionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteModelExplainabilityJobDefinition{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteModelExplainabilityJobDefinition{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteModelExplainabilityJobDefinitionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteModelExplainabilityJobDefinition(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDeleteModelExplainabilityJobDefinition(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteModelExplainabilityJobDefinition",
}
}

121
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DeleteModelPackage.go generated vendored Normal file
View File

@@ -0,0 +1,121 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a model package. A model package is used to create Amazon SageMaker
// models or list on Amazon Web Services Marketplace. Buyers can subscribe to model
// packages listed on Amazon Web Services Marketplace to create models in Amazon
// SageMaker.
func (c *Client) DeleteModelPackage(ctx context.Context, params *DeleteModelPackageInput, optFns ...func(*Options)) (*DeleteModelPackageOutput, error) {
if params == nil {
params = &DeleteModelPackageInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteModelPackage", params, optFns, c.addOperationDeleteModelPackageMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteModelPackageOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteModelPackageInput struct {
// The name or Amazon Resource Name (ARN) of the model package to delete. When you
// specify a name, the name must have 1 to 63 characters. Valid characters are a-z,
// A-Z, 0-9, and - (hyphen).
//
// This member is required.
ModelPackageName *string
noSmithyDocumentSerde
}
type DeleteModelPackageOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteModelPackageMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteModelPackage{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteModelPackage{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteModelPackageValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteModelPackage(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDeleteModelPackage(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteModelPackage",
}
}

116
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DeleteModelPackageGroup.go generated vendored Normal file
View File

@@ -0,0 +1,116 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes the specified model group.
func (c *Client) DeleteModelPackageGroup(ctx context.Context, params *DeleteModelPackageGroupInput, optFns ...func(*Options)) (*DeleteModelPackageGroupOutput, error) {
if params == nil {
params = &DeleteModelPackageGroupInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteModelPackageGroup", params, optFns, c.addOperationDeleteModelPackageGroupMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteModelPackageGroupOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteModelPackageGroupInput struct {
// The name of the model group to delete.
//
// This member is required.
ModelPackageGroupName *string
noSmithyDocumentSerde
}
type DeleteModelPackageGroupOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteModelPackageGroupMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteModelPackageGroup{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteModelPackageGroup{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteModelPackageGroupValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteModelPackageGroup(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDeleteModelPackageGroup(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteModelPackageGroup",
}
}

116
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DeleteModelPackageGroupPolicy.go generated vendored Normal file
View File

@@ -0,0 +1,116 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a model group resource policy.
func (c *Client) DeleteModelPackageGroupPolicy(ctx context.Context, params *DeleteModelPackageGroupPolicyInput, optFns ...func(*Options)) (*DeleteModelPackageGroupPolicyOutput, error) {
if params == nil {
params = &DeleteModelPackageGroupPolicyInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteModelPackageGroupPolicy", params, optFns, c.addOperationDeleteModelPackageGroupPolicyMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteModelPackageGroupPolicyOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteModelPackageGroupPolicyInput struct {
// The name of the model group for which to delete the policy.
//
// This member is required.
ModelPackageGroupName *string
noSmithyDocumentSerde
}
type DeleteModelPackageGroupPolicyOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteModelPackageGroupPolicyMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteModelPackageGroupPolicy{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteModelPackageGroupPolicy{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteModelPackageGroupPolicyValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteModelPackageGroupPolicy(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDeleteModelPackageGroupPolicy(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteModelPackageGroupPolicy",
}
}

116
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DeleteModelQualityJobDefinition.go generated vendored Normal file
View File

@@ -0,0 +1,116 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes the secified model quality monitoring job definition.
func (c *Client) DeleteModelQualityJobDefinition(ctx context.Context, params *DeleteModelQualityJobDefinitionInput, optFns ...func(*Options)) (*DeleteModelQualityJobDefinitionOutput, error) {
if params == nil {
params = &DeleteModelQualityJobDefinitionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteModelQualityJobDefinition", params, optFns, c.addOperationDeleteModelQualityJobDefinitionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteModelQualityJobDefinitionOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteModelQualityJobDefinitionInput struct {
// The name of the model quality monitoring job definition to delete.
//
// This member is required.
JobDefinitionName *string
noSmithyDocumentSerde
}
type DeleteModelQualityJobDefinitionOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteModelQualityJobDefinitionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteModelQualityJobDefinition{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteModelQualityJobDefinition{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteModelQualityJobDefinitionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteModelQualityJobDefinition(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDeleteModelQualityJobDefinition(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteModelQualityJobDefinition",
}
}

118
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DeleteMonitoringSchedule.go generated vendored Normal file
View File

@@ -0,0 +1,118 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a monitoring schedule. Also stops the schedule had not already been
// stopped. This does not delete the job execution history of the monitoring
// schedule.
func (c *Client) DeleteMonitoringSchedule(ctx context.Context, params *DeleteMonitoringScheduleInput, optFns ...func(*Options)) (*DeleteMonitoringScheduleOutput, error) {
if params == nil {
params = &DeleteMonitoringScheduleInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteMonitoringSchedule", params, optFns, c.addOperationDeleteMonitoringScheduleMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteMonitoringScheduleOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteMonitoringScheduleInput struct {
// The name of the monitoring schedule to delete.
//
// This member is required.
MonitoringScheduleName *string
noSmithyDocumentSerde
}
type DeleteMonitoringScheduleOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteMonitoringScheduleMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteMonitoringSchedule{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteMonitoringSchedule{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteMonitoringScheduleValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteMonitoringSchedule(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDeleteMonitoringSchedule(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteMonitoringSchedule",
}
}

120
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DeleteNotebookInstance.go generated vendored Normal file
View File

@@ -0,0 +1,120 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes an Amazon SageMaker notebook instance. Before you can delete a notebook
// instance, you must call the StopNotebookInstance API. When you delete a notebook
// instance, you lose all of your data. Amazon SageMaker removes the ML compute
// instance, and deletes the ML storage volume and the network interface associated
// with the notebook instance.
func (c *Client) DeleteNotebookInstance(ctx context.Context, params *DeleteNotebookInstanceInput, optFns ...func(*Options)) (*DeleteNotebookInstanceOutput, error) {
if params == nil {
params = &DeleteNotebookInstanceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteNotebookInstance", params, optFns, c.addOperationDeleteNotebookInstanceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteNotebookInstanceOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteNotebookInstanceInput struct {
// The name of the Amazon SageMaker notebook instance to delete.
//
// This member is required.
NotebookInstanceName *string
noSmithyDocumentSerde
}
type DeleteNotebookInstanceOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteNotebookInstanceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteNotebookInstance{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteNotebookInstance{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteNotebookInstanceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteNotebookInstance(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDeleteNotebookInstance(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteNotebookInstance",
}
}

116
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DeleteNotebookInstanceLifecycleConfig.go generated vendored Normal file
View File

@@ -0,0 +1,116 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a notebook instance lifecycle configuration.
func (c *Client) DeleteNotebookInstanceLifecycleConfig(ctx context.Context, params *DeleteNotebookInstanceLifecycleConfigInput, optFns ...func(*Options)) (*DeleteNotebookInstanceLifecycleConfigOutput, error) {
if params == nil {
params = &DeleteNotebookInstanceLifecycleConfigInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteNotebookInstanceLifecycleConfig", params, optFns, c.addOperationDeleteNotebookInstanceLifecycleConfigMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteNotebookInstanceLifecycleConfigOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteNotebookInstanceLifecycleConfigInput struct {
// The name of the lifecycle configuration to delete.
//
// This member is required.
NotebookInstanceLifecycleConfigName *string
noSmithyDocumentSerde
}
type DeleteNotebookInstanceLifecycleConfigOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteNotebookInstanceLifecycleConfigMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteNotebookInstanceLifecycleConfig{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteNotebookInstanceLifecycleConfig{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteNotebookInstanceLifecycleConfigValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteNotebookInstanceLifecycleConfig(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDeleteNotebookInstanceLifecycleConfig(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteNotebookInstanceLifecycleConfig",
}
}

166
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DeletePipeline.go generated vendored Normal file
View File

@@ -0,0 +1,166 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
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/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a pipeline if there are no running instances of the pipeline. To delete
// a pipeline, you must stop all running instances of the pipeline using the
// StopPipelineExecution API. When you delete a pipeline, all instances of the
// pipeline are deleted.
func (c *Client) DeletePipeline(ctx context.Context, params *DeletePipelineInput, optFns ...func(*Options)) (*DeletePipelineOutput, error) {
if params == nil {
params = &DeletePipelineInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeletePipeline", params, optFns, c.addOperationDeletePipelineMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeletePipelineOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeletePipelineInput struct {
// A unique, case-sensitive identifier that you provide to ensure the idempotency
// of the operation. An idempotent operation completes no more than one time.
//
// This member is required.
ClientRequestToken *string
// The name of the pipeline to delete.
//
// This member is required.
PipelineName *string
noSmithyDocumentSerde
}
type DeletePipelineOutput struct {
// The Amazon Resource Name (ARN) of the pipeline to delete.
PipelineArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeletePipelineMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeletePipeline{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeletePipeline{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addIdempotencyToken_opDeletePipelineMiddleware(stack, options); err != nil {
return err
}
if err = addOpDeletePipelineValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeletePipeline(options.Region), middleware.Before); 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
}
return nil
}
type idempotencyToken_initializeOpDeletePipeline struct {
tokenProvider IdempotencyTokenProvider
}
func (*idempotencyToken_initializeOpDeletePipeline) ID() string {
return "OperationIdempotencyTokenAutoFill"
}
func (m *idempotencyToken_initializeOpDeletePipeline) 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.(*DeletePipelineInput)
if !ok {
return out, metadata, fmt.Errorf("expected middleware input to be of type *DeletePipelineInput ")
}
if input.ClientRequestToken == nil {
t, err := m.tokenProvider.GetIdempotencyToken()
if err != nil {
return out, metadata, err
}
input.ClientRequestToken = &t
}
return next.HandleInitialize(ctx, in)
}
func addIdempotencyToken_opDeletePipelineMiddleware(stack *middleware.Stack, cfg Options) error {
return stack.Initialize.Add(&idempotencyToken_initializeOpDeletePipeline{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before)
}
func newServiceMetadataMiddleware_opDeletePipeline(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeletePipeline",
}
}

116
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DeleteProject.go generated vendored Normal file
View File

@@ -0,0 +1,116 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Delete the specified project.
func (c *Client) DeleteProject(ctx context.Context, params *DeleteProjectInput, optFns ...func(*Options)) (*DeleteProjectOutput, error) {
if params == nil {
params = &DeleteProjectInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteProject", params, optFns, c.addOperationDeleteProjectMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteProjectOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteProjectInput struct {
// The name of the project to delete.
//
// This member is required.
ProjectName *string
noSmithyDocumentSerde
}
type DeleteProjectOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteProjectMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteProject{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteProject{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteProjectValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteProject(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDeleteProject(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteProject",
}
}

119
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DeleteStudioLifecycleConfig.go generated vendored Normal file
View File

@@ -0,0 +1,119 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes the Studio Lifecycle Configuration. In order to delete the Lifecycle
// Configuration, there must be no running apps using the Lifecycle Configuration.
// You must also remove the Lifecycle Configuration from UserSettings in all
// Domains and UserProfiles.
func (c *Client) DeleteStudioLifecycleConfig(ctx context.Context, params *DeleteStudioLifecycleConfigInput, optFns ...func(*Options)) (*DeleteStudioLifecycleConfigOutput, error) {
if params == nil {
params = &DeleteStudioLifecycleConfigInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteStudioLifecycleConfig", params, optFns, c.addOperationDeleteStudioLifecycleConfigMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteStudioLifecycleConfigOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteStudioLifecycleConfigInput struct {
// The name of the Studio Lifecycle Configuration to delete.
//
// This member is required.
StudioLifecycleConfigName *string
noSmithyDocumentSerde
}
type DeleteStudioLifecycleConfigOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteStudioLifecycleConfigMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteStudioLifecycleConfig{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteStudioLifecycleConfig{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteStudioLifecycleConfigValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteStudioLifecycleConfig(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDeleteStudioLifecycleConfig(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteStudioLifecycleConfig",
}
}

127
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DeleteTags.go generated vendored Normal file
View File

@@ -0,0 +1,127 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes the specified tags from an Amazon SageMaker resource. To list a
// resource's tags, use the ListTags API. When you call this API to delete tags
// from a hyperparameter tuning job, the deleted tags are not removed from training
// jobs that the hyperparameter tuning job launched before you called this API.
// When you call this API to delete tags from a SageMaker Studio Domain or User
// Profile, the deleted tags are not removed from Apps that the SageMaker Studio
// Domain or User Profile launched before you called this API.
func (c *Client) DeleteTags(ctx context.Context, params *DeleteTagsInput, optFns ...func(*Options)) (*DeleteTagsOutput, error) {
if params == nil {
params = &DeleteTagsInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteTags", params, optFns, c.addOperationDeleteTagsMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteTagsOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteTagsInput struct {
// The Amazon Resource Name (ARN) of the resource whose tags you want to delete.
//
// This member is required.
ResourceArn *string
// An array or one or more tag keys to delete.
//
// This member is required.
TagKeys []string
noSmithyDocumentSerde
}
type DeleteTagsOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteTagsMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteTags{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteTags{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteTagsValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteTags(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDeleteTags(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteTags",
}
}

122
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DeleteTrial.go generated vendored Normal file
View File

@@ -0,0 +1,122 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes the specified trial. All trial components that make up the trial must be
// deleted first. Use the DescribeTrialComponent API to get the list of trial
// components.
func (c *Client) DeleteTrial(ctx context.Context, params *DeleteTrialInput, optFns ...func(*Options)) (*DeleteTrialOutput, error) {
if params == nil {
params = &DeleteTrialInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteTrial", params, optFns, c.addOperationDeleteTrialMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteTrialOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteTrialInput struct {
// The name of the trial to delete.
//
// This member is required.
TrialName *string
noSmithyDocumentSerde
}
type DeleteTrialOutput struct {
// The Amazon Resource Name (ARN) of the trial that is being deleted.
TrialArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteTrialMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteTrial{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteTrial{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteTrialValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteTrial(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDeleteTrial(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteTrial",
}
}

122
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DeleteTrialComponent.go generated vendored Normal file
View File

@@ -0,0 +1,122 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes the specified trial component. A trial component must be disassociated
// from all trials before the trial component can be deleted. To disassociate a
// trial component from a trial, call the DisassociateTrialComponent API.
func (c *Client) DeleteTrialComponent(ctx context.Context, params *DeleteTrialComponentInput, optFns ...func(*Options)) (*DeleteTrialComponentOutput, error) {
if params == nil {
params = &DeleteTrialComponentInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteTrialComponent", params, optFns, c.addOperationDeleteTrialComponentMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteTrialComponentOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteTrialComponentInput struct {
// The name of the component to delete.
//
// This member is required.
TrialComponentName *string
noSmithyDocumentSerde
}
type DeleteTrialComponentOutput struct {
// The Amazon Resource Name (ARN) of the component is being deleted.
TrialComponentArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteTrialComponentMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteTrialComponent{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteTrialComponent{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteTrialComponentValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteTrialComponent(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDeleteTrialComponent(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteTrialComponent",
}
}

122
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DeleteUserProfile.go generated vendored Normal file
View File

@@ -0,0 +1,122 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes a user profile. When a user profile is deleted, the user loses access to
// their EFS volume, including data, notebooks, and other artifacts.
func (c *Client) DeleteUserProfile(ctx context.Context, params *DeleteUserProfileInput, optFns ...func(*Options)) (*DeleteUserProfileOutput, error) {
if params == nil {
params = &DeleteUserProfileInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteUserProfile", params, optFns, c.addOperationDeleteUserProfileMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteUserProfileOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteUserProfileInput struct {
// The domain ID.
//
// This member is required.
DomainId *string
// The user profile name.
//
// This member is required.
UserProfileName *string
noSmithyDocumentSerde
}
type DeleteUserProfileOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteUserProfileMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteUserProfile{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteUserProfile{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteUserProfileValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteUserProfile(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDeleteUserProfile(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteUserProfile",
}
}

122
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DeleteWorkforce.go generated vendored Normal file
View File

@@ -0,0 +1,122 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Use this operation to delete a workforce. If you want to create a new workforce
// in an Amazon Web Services Region where a workforce already exists, use this
// operation to delete the existing workforce and then use to create a new
// workforce. If a private workforce contains one or more work teams, you must use
// the operation to delete all work teams before you delete the workforce. If you
// try to delete a workforce that contains one or more work teams, you will recieve
// a ResourceInUse error.
func (c *Client) DeleteWorkforce(ctx context.Context, params *DeleteWorkforceInput, optFns ...func(*Options)) (*DeleteWorkforceOutput, error) {
if params == nil {
params = &DeleteWorkforceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteWorkforce", params, optFns, c.addOperationDeleteWorkforceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteWorkforceOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteWorkforceInput struct {
// The name of the workforce.
//
// This member is required.
WorkforceName *string
noSmithyDocumentSerde
}
type DeleteWorkforceOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteWorkforceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteWorkforce{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteWorkforce{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteWorkforceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteWorkforce(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDeleteWorkforce(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteWorkforce",
}
}

123
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DeleteWorkteam.go generated vendored Normal file
View File

@@ -0,0 +1,123 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deletes an existing work team. This operation can't be undone.
func (c *Client) DeleteWorkteam(ctx context.Context, params *DeleteWorkteamInput, optFns ...func(*Options)) (*DeleteWorkteamOutput, error) {
if params == nil {
params = &DeleteWorkteamInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteWorkteam", params, optFns, c.addOperationDeleteWorkteamMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteWorkteamOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteWorkteamInput struct {
// The name of the work team to delete.
//
// This member is required.
WorkteamName *string
noSmithyDocumentSerde
}
type DeleteWorkteamOutput struct {
// Returns true if the work team was successfully deleted; otherwise, returns
// false.
//
// This member is required.
Success bool
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteWorkteamMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteWorkteam{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteWorkteam{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeleteWorkteamValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteWorkteam(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDeleteWorkteam(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteWorkteam",
}
}

122
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DeregisterDevices.go generated vendored Normal file
View File

@@ -0,0 +1,122 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// Deregisters the specified devices. After you deregister a device, you will need
// to re-register the devices.
func (c *Client) DeregisterDevices(ctx context.Context, params *DeregisterDevicesInput, optFns ...func(*Options)) (*DeregisterDevicesOutput, error) {
if params == nil {
params = &DeregisterDevicesInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeregisterDevices", params, optFns, c.addOperationDeregisterDevicesMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeregisterDevicesOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeregisterDevicesInput struct {
// The name of the fleet the devices belong to.
//
// This member is required.
DeviceFleetName *string
// The unique IDs of the devices.
//
// This member is required.
DeviceNames []string
noSmithyDocumentSerde
}
type DeregisterDevicesOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeregisterDevicesMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeregisterDevices{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeregisterDevices{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDeregisterDevicesValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeregisterDevices(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDeregisterDevices(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeregisterDevices",
}
}

157
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DescribeAction.go generated vendored Normal file
View File

@@ -0,0 +1,157 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Describes an action.
func (c *Client) DescribeAction(ctx context.Context, params *DescribeActionInput, optFns ...func(*Options)) (*DescribeActionOutput, error) {
if params == nil {
params = &DescribeActionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeAction", params, optFns, c.addOperationDescribeActionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeActionOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeActionInput struct {
// The name of the action to describe.
//
// This member is required.
ActionName *string
noSmithyDocumentSerde
}
type DescribeActionOutput struct {
// The Amazon Resource Name (ARN) of the action.
ActionArn *string
// The name of the action.
ActionName *string
// The type of the action.
ActionType *string
// Information about the user who created or modified an experiment, trial, trial
// component, or project.
CreatedBy *types.UserContext
// When the action was created.
CreationTime *time.Time
// The description of the action.
Description *string
// Information about the user who created or modified an experiment, trial, trial
// component, or project.
LastModifiedBy *types.UserContext
// When the action was last modified.
LastModifiedTime *time.Time
// Metadata properties of the tracking entity, trial, or trial component.
MetadataProperties *types.MetadataProperties
// A list of the action's properties.
Properties map[string]string
// The source of the action.
Source *types.ActionSource
// The status of the action.
Status types.ActionStatus
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeActionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeAction{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeAction{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeActionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeAction(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDescribeAction(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DescribeAction",
}
}

166
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DescribeAlgorithm.go generated vendored Normal file
View File

@@ -0,0 +1,166 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Returns a description of the specified algorithm that is in your account.
func (c *Client) DescribeAlgorithm(ctx context.Context, params *DescribeAlgorithmInput, optFns ...func(*Options)) (*DescribeAlgorithmOutput, error) {
if params == nil {
params = &DescribeAlgorithmInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeAlgorithm", params, optFns, c.addOperationDescribeAlgorithmMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeAlgorithmOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeAlgorithmInput struct {
// The name of the algorithm to describe.
//
// This member is required.
AlgorithmName *string
noSmithyDocumentSerde
}
type DescribeAlgorithmOutput struct {
// The Amazon Resource Name (ARN) of the algorithm.
//
// This member is required.
AlgorithmArn *string
// The name of the algorithm being described.
//
// This member is required.
AlgorithmName *string
// The current status of the algorithm.
//
// This member is required.
AlgorithmStatus types.AlgorithmStatus
// Details about the current status of the algorithm.
//
// This member is required.
AlgorithmStatusDetails *types.AlgorithmStatusDetails
// A timestamp specifying when the algorithm was created.
//
// This member is required.
CreationTime *time.Time
// Details about training jobs run by this algorithm.
//
// This member is required.
TrainingSpecification *types.TrainingSpecification
// A brief summary about the algorithm.
AlgorithmDescription *string
// Whether the algorithm is certified to be listed in Amazon Web Services
// Marketplace.
CertifyForMarketplace bool
// Details about inference jobs that the algorithm runs.
InferenceSpecification *types.InferenceSpecification
// The product identifier of the algorithm.
ProductId *string
// Details about configurations for one or more training jobs that Amazon SageMaker
// runs to test the algorithm.
ValidationSpecification *types.AlgorithmValidationSpecification
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeAlgorithmMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeAlgorithm{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeAlgorithm{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeAlgorithmValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeAlgorithm(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDescribeAlgorithm(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DescribeAlgorithm",
}
}

168
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DescribeApp.go generated vendored Normal file
View File

@@ -0,0 +1,168 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Describes the app.
func (c *Client) DescribeApp(ctx context.Context, params *DescribeAppInput, optFns ...func(*Options)) (*DescribeAppOutput, error) {
if params == nil {
params = &DescribeAppInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeApp", params, optFns, c.addOperationDescribeAppMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeAppOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeAppInput struct {
// The name of the app.
//
// This member is required.
AppName *string
// The type of app.
//
// This member is required.
AppType types.AppType
// The domain ID.
//
// This member is required.
DomainId *string
// The user profile name.
//
// This member is required.
UserProfileName *string
noSmithyDocumentSerde
}
type DescribeAppOutput struct {
// The Amazon Resource Name (ARN) of the app.
AppArn *string
// The name of the app.
AppName *string
// The type of app.
AppType types.AppType
// The creation time.
CreationTime *time.Time
// The domain ID.
DomainId *string
// The failure reason.
FailureReason *string
// The timestamp of the last health check.
LastHealthCheckTimestamp *time.Time
// The timestamp of the last user's activity.
LastUserActivityTimestamp *time.Time
// The instance type and the Amazon Resource Name (ARN) of the SageMaker image
// created on the instance.
ResourceSpec *types.ResourceSpec
// The status.
Status types.AppStatus
// The user profile name.
UserProfileName *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeAppMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeApp{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeApp{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeAppValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeApp(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDescribeApp(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DescribeApp",
}
}

134
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DescribeAppImageConfig.go generated vendored Normal file
View File

@@ -0,0 +1,134 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Describes an AppImageConfig.
func (c *Client) DescribeAppImageConfig(ctx context.Context, params *DescribeAppImageConfigInput, optFns ...func(*Options)) (*DescribeAppImageConfigOutput, error) {
if params == nil {
params = &DescribeAppImageConfigInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeAppImageConfig", params, optFns, c.addOperationDescribeAppImageConfigMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeAppImageConfigOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeAppImageConfigInput struct {
// The name of the AppImageConfig to describe.
//
// This member is required.
AppImageConfigName *string
noSmithyDocumentSerde
}
type DescribeAppImageConfigOutput struct {
// The Amazon Resource Name (ARN) of the AppImageConfig.
AppImageConfigArn *string
// The name of the AppImageConfig.
AppImageConfigName *string
// When the AppImageConfig was created.
CreationTime *time.Time
// The configuration of a KernelGateway app.
KernelGatewayImageConfig *types.KernelGatewayImageConfig
// When the AppImageConfig was last modified.
LastModifiedTime *time.Time
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeAppImageConfigMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeAppImageConfig{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeAppImageConfig{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeAppImageConfigValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeAppImageConfig(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDescribeAppImageConfig(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DescribeAppImageConfig",
}
}

151
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DescribeArtifact.go generated vendored Normal file
View File

@@ -0,0 +1,151 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Describes an artifact.
func (c *Client) DescribeArtifact(ctx context.Context, params *DescribeArtifactInput, optFns ...func(*Options)) (*DescribeArtifactOutput, error) {
if params == nil {
params = &DescribeArtifactInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeArtifact", params, optFns, c.addOperationDescribeArtifactMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeArtifactOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeArtifactInput struct {
// The Amazon Resource Name (ARN) of the artifact to describe.
//
// This member is required.
ArtifactArn *string
noSmithyDocumentSerde
}
type DescribeArtifactOutput struct {
// The Amazon Resource Name (ARN) of the artifact.
ArtifactArn *string
// The name of the artifact.
ArtifactName *string
// The type of the artifact.
ArtifactType *string
// Information about the user who created or modified an experiment, trial, trial
// component, or project.
CreatedBy *types.UserContext
// When the artifact was created.
CreationTime *time.Time
// Information about the user who created or modified an experiment, trial, trial
// component, or project.
LastModifiedBy *types.UserContext
// When the artifact was last modified.
LastModifiedTime *time.Time
// Metadata properties of the tracking entity, trial, or trial component.
MetadataProperties *types.MetadataProperties
// A list of the artifact's properties.
Properties map[string]string
// The source of the artifact.
Source *types.ArtifactSource
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeArtifactMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeArtifact{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeArtifact{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeArtifactValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeArtifact(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDescribeArtifact(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DescribeArtifact",
}
}

206
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DescribeAutoMLJob.go generated vendored Normal file
View File

@@ -0,0 +1,206 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Returns information about an Amazon SageMaker AutoML job.
func (c *Client) DescribeAutoMLJob(ctx context.Context, params *DescribeAutoMLJobInput, optFns ...func(*Options)) (*DescribeAutoMLJobOutput, error) {
if params == nil {
params = &DescribeAutoMLJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeAutoMLJob", params, optFns, c.addOperationDescribeAutoMLJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeAutoMLJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeAutoMLJobInput struct {
// Requests information about an AutoML job using its unique name.
//
// This member is required.
AutoMLJobName *string
noSmithyDocumentSerde
}
type DescribeAutoMLJobOutput struct {
// Returns the ARN of the AutoML job.
//
// This member is required.
AutoMLJobArn *string
// Returns the name of the AutoML job.
//
// This member is required.
AutoMLJobName *string
// Returns the secondary status of the AutoML job.
//
// This member is required.
AutoMLJobSecondaryStatus types.AutoMLJobSecondaryStatus
// Returns the status of the AutoML job.
//
// This member is required.
AutoMLJobStatus types.AutoMLJobStatus
// Returns the creation time of the AutoML job.
//
// This member is required.
CreationTime *time.Time
// Returns the input data configuration for the AutoML job..
//
// This member is required.
InputDataConfig []types.AutoMLChannel
// Returns the job's last modified time.
//
// This member is required.
LastModifiedTime *time.Time
// Returns the job's output data config.
//
// This member is required.
OutputDataConfig *types.AutoMLOutputDataConfig
// The Amazon Resource Name (ARN) of the Amazon Web Services Identity and Access
// Management (IAM) role that has read permission to the input data location and
// write permission to the output data location in Amazon S3.
//
// This member is required.
RoleArn *string
// Returns information on the job's artifacts found in AutoMLJobArtifacts.
AutoMLJobArtifacts *types.AutoMLJobArtifacts
// Returns the configuration for the AutoML job.
AutoMLJobConfig *types.AutoMLJobConfig
// Returns the job's objective.
AutoMLJobObjective *types.AutoMLJobObjective
// Returns the job's best AutoMLCandidate.
BestCandidate *types.AutoMLCandidate
// Returns the end time of the AutoML job.
EndTime *time.Time
// Returns the failure reason for an AutoML job, when applicable.
FailureReason *string
// Indicates whether the output for an AutoML job generates candidate definitions
// only.
GenerateCandidateDefinitionsOnly bool
// Indicates whether the model was deployed automatically to an endpoint and the
// name of that endpoint if deployed automatically.
ModelDeployConfig *types.ModelDeployConfig
// Provides information about endpoint for the model deployment.
ModelDeployResult *types.ModelDeployResult
// Returns a list of reasons for partial failures within an AutoML job.
PartialFailureReasons []types.AutoMLPartialFailureReason
// Returns the job's problem type.
ProblemType types.ProblemType
// This contains ProblemType, AutoMLJobObjective, and CompletionCriteria. If you do
// not provide these values, they are auto-inferred. If you do provide them, the
// values used are the ones you provide.
ResolvedAttributes *types.ResolvedAttributes
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeAutoMLJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeAutoMLJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeAutoMLJob{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeAutoMLJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeAutoMLJob(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDescribeAutoMLJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DescribeAutoMLJob",
}
}

145
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DescribeCodeRepository.go generated vendored Normal file
View File

@@ -0,0 +1,145 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Gets details about the specified Git repository.
func (c *Client) DescribeCodeRepository(ctx context.Context, params *DescribeCodeRepositoryInput, optFns ...func(*Options)) (*DescribeCodeRepositoryOutput, error) {
if params == nil {
params = &DescribeCodeRepositoryInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeCodeRepository", params, optFns, c.addOperationDescribeCodeRepositoryMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeCodeRepositoryOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeCodeRepositoryInput struct {
// The name of the Git repository to describe.
//
// This member is required.
CodeRepositoryName *string
noSmithyDocumentSerde
}
type DescribeCodeRepositoryOutput struct {
// The Amazon Resource Name (ARN) of the Git repository.
//
// This member is required.
CodeRepositoryArn *string
// The name of the Git repository.
//
// This member is required.
CodeRepositoryName *string
// The date and time that the repository was created.
//
// This member is required.
CreationTime *time.Time
// The date and time that the repository was last changed.
//
// This member is required.
LastModifiedTime *time.Time
// Configuration details about the repository, including the URL where the
// repository is located, the default branch, and the Amazon Resource Name (ARN) of
// the Amazon Web Services Secrets Manager secret that contains the credentials
// used to access the repository.
GitConfig *types.GitConfig
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeCodeRepositoryMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeCodeRepository{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeCodeRepository{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeCodeRepositoryValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeCodeRepository(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDescribeCodeRepository(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DescribeCodeRepository",
}
}

211
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DescribeCompilationJob.go generated vendored Normal file
View File

@@ -0,0 +1,211 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Returns information about a model compilation job. To create a model compilation
// job, use CreateCompilationJob. To get information about multiple model
// compilation jobs, use ListCompilationJobs.
func (c *Client) DescribeCompilationJob(ctx context.Context, params *DescribeCompilationJobInput, optFns ...func(*Options)) (*DescribeCompilationJobOutput, error) {
if params == nil {
params = &DescribeCompilationJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeCompilationJob", params, optFns, c.addOperationDescribeCompilationJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeCompilationJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeCompilationJobInput struct {
// The name of the model compilation job that you want information about.
//
// This member is required.
CompilationJobName *string
noSmithyDocumentSerde
}
type DescribeCompilationJobOutput struct {
// The Amazon Resource Name (ARN) of the model compilation job.
//
// This member is required.
CompilationJobArn *string
// The name of the model compilation job.
//
// This member is required.
CompilationJobName *string
// The status of the model compilation job.
//
// This member is required.
CompilationJobStatus types.CompilationJobStatus
// The time that the model compilation job was created.
//
// This member is required.
CreationTime *time.Time
// If a model compilation job failed, the reason it failed.
//
// This member is required.
FailureReason *string
// Information about the location in Amazon S3 of the input model artifacts, the
// name and shape of the expected data inputs, and the framework in which the model
// was trained.
//
// This member is required.
InputConfig *types.InputConfig
// The time that the status of the model compilation job was last modified.
//
// This member is required.
LastModifiedTime *time.Time
// Information about the location in Amazon S3 that has been configured for storing
// the model artifacts used in the compilation job.
//
// This member is required.
ModelArtifacts *types.ModelArtifacts
// Information about the output location for the compiled model and the target
// device that the model runs on.
//
// This member is required.
OutputConfig *types.OutputConfig
// The Amazon Resource Name (ARN) of an IAM role that Amazon SageMaker assumes to
// perform the model compilation job.
//
// This member is required.
RoleArn *string
// Specifies a limit to how long a model compilation job can run. When the job
// reaches the time limit, Amazon SageMaker ends the compilation job. Use this API
// to cap model training costs.
//
// This member is required.
StoppingCondition *types.StoppingCondition
// The time when the model compilation job on a compilation job instance ended. For
// a successful or stopped job, this is when the job's model artifacts have
// finished uploading. For a failed job, this is when Amazon SageMaker detected
// that the job failed.
CompilationEndTime *time.Time
// The time when the model compilation job started the CompilationJob instances.
// You are billed for the time between this timestamp and the timestamp in the
// DescribeCompilationJobResponse$CompilationEndTime field. In Amazon CloudWatch
// Logs, the start time might be later than this time. That's because it takes time
// to download the compilation job, which depends on the size of the compilation
// job container.
CompilationStartTime *time.Time
// The inference image to use when compiling a model. Specify an image only if the
// target device is a cloud instance.
InferenceImage *string
// Provides a BLAKE2 hash value that identifies the compiled model artifacts in
// Amazon S3.
ModelDigests *types.ModelDigests
// A VpcConfig object that specifies the VPC that you want your compilation job to
// connect to. Control access to your models by configuring the VPC. For more
// information, see Protect Compilation Jobs by Using an Amazon Virtual Private
// Cloud (https://docs.aws.amazon.com/sagemaker/latest/dg/neo-vpc.html).
VpcConfig *types.NeoVpcConfig
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeCompilationJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeCompilationJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeCompilationJob{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeCompilationJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeCompilationJob(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDescribeCompilationJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DescribeCompilationJob",
}
}

151
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DescribeContext.go generated vendored Normal file
View File

@@ -0,0 +1,151 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Describes a context.
func (c *Client) DescribeContext(ctx context.Context, params *DescribeContextInput, optFns ...func(*Options)) (*DescribeContextOutput, error) {
if params == nil {
params = &DescribeContextInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeContext", params, optFns, c.addOperationDescribeContextMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeContextOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeContextInput struct {
// The name of the context to describe.
//
// This member is required.
ContextName *string
noSmithyDocumentSerde
}
type DescribeContextOutput struct {
// The Amazon Resource Name (ARN) of the context.
ContextArn *string
// The name of the context.
ContextName *string
// The type of the context.
ContextType *string
// Information about the user who created or modified an experiment, trial, trial
// component, or project.
CreatedBy *types.UserContext
// When the context was created.
CreationTime *time.Time
// The description of the context.
Description *string
// Information about the user who created or modified an experiment, trial, trial
// component, or project.
LastModifiedBy *types.UserContext
// When the context was last modified.
LastModifiedTime *time.Time
// A list of the context's properties.
Properties map[string]string
// The source of the context.
Source *types.ContextSource
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeContextMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeContext{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeContext{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeContextValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeContext(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDescribeContext(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DescribeContext",
}
}

170
vendor/github.com/aws/aws-sdk-go-v2/service/sagemaker/api_op_DescribeDataQualityJobDefinition.go generated vendored Normal file
View File

@@ -0,0 +1,170 @@
// Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
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/sagemaker/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
"time"
)
// Gets the details of a data quality monitoring job definition.
func (c *Client) DescribeDataQualityJobDefinition(ctx context.Context, params *DescribeDataQualityJobDefinitionInput, optFns ...func(*Options)) (*DescribeDataQualityJobDefinitionOutput, error) {
if params == nil {
params = &DescribeDataQualityJobDefinitionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeDataQualityJobDefinition", params, optFns, c.addOperationDescribeDataQualityJobDefinitionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeDataQualityJobDefinitionOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeDataQualityJobDefinitionInput struct {
// The name of the data quality monitoring job definition to describe.
//
// This member is required.
JobDefinitionName *string
noSmithyDocumentSerde
}
type DescribeDataQualityJobDefinitionOutput struct {
// The time that the data quality monitoring job definition was created.
//
// This member is required.
CreationTime *time.Time
// Information about the container that runs the data quality monitoring job.
//
// This member is required.
DataQualityAppSpecification *types.DataQualityAppSpecification
// The list of inputs for the data quality monitoring job. Currently endpoints are
// supported.
//
// This member is required.
DataQualityJobInput *types.DataQualityJobInput
// The output configuration for monitoring jobs.
//
// This member is required.
DataQualityJobOutputConfig *types.MonitoringOutputConfig
// The Amazon Resource Name (ARN) of the data quality monitoring job definition.
//
// This member is required.
JobDefinitionArn *string
// The name of the data quality monitoring job definition.
//
// This member is required.
JobDefinitionName *string
// Identifies the resources to deploy for a monitoring job.
//
// This member is required.
JobResources *types.MonitoringResources
// The Amazon Resource Name (ARN) of an IAM role that Amazon SageMaker can assume
// to perform tasks on your behalf.
//
// This member is required.
RoleArn *string
// The constraints and baselines for the data quality monitoring job definition.
DataQualityBaselineConfig *types.DataQualityBaselineConfig
// The networking configuration for the data quality monitoring job.
NetworkConfig *types.MonitoringNetworkConfig
// A time limit for how long the monitoring job is allowed to run before stopping.
StoppingCondition *types.MonitoringStoppingCondition
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeDataQualityJobDefinitionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeDataQualityJobDefinition{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeDataQualityJobDefinition{}, middleware.After)
if 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 = addHTTPSignerV4Middleware(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); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addOpDescribeDataQualityJobDefinitionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeDataQualityJobDefinition(options.Region), middleware.Before); 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
}
return nil
}
func newServiceMetadataMiddleware_opDescribeDataQualityJobDefinition(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DescribeDataQualityJobDefinition",
}
}

Some files were not shown because too many files have changed in this diff Show More