repo_name
stringlengths 1
52
| repo_creator
stringclasses 6
values | programming_language
stringclasses 4
values | code
stringlengths 0
9.68M
| num_lines
int64 1
234k
|
|---|---|---|---|---|
aws-sdk-go-v2 | aws | Go | // 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateLabelingJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateLabelingJob",
}
}
| 276 |
aws-sdk-go-v2 | aws | Go | // 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 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 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. 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 SageMaker hosting
// services, see Create a Model (Amazon Web Services SDK for Python (Boto 3)). (https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints-deployment.html#realtime-endpoints-deployment-create-model)
// To run a batch transform using your model, you start a job with the
// CreateTransformJob API. SageMaker uses your model and your dataset to get
// inferences which are then saved to a specified S3 location. In the request, you
// also provide an IAM role that 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 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 SageMaker Roles (https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html)
// . To be able to pass this role to 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 (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_VpcConfig.html)
// 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 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateModel(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateModel",
}
}
| 185 |
aws-sdk-go-v2 | aws | Go | // 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateModelBiasJobDefinition(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateModelBiasJobDefinition",
}
}
| 168 |
aws-sdk-go-v2 | aws | Go | // 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 Model Card. For information about how to use model
// cards, see Amazon SageMaker Model Card (https://docs.aws.amazon.com/sagemaker/latest/dg/model-cards.html)
// .
func (c *Client) CreateModelCard(ctx context.Context, params *CreateModelCardInput, optFns ...func(*Options)) (*CreateModelCardOutput, error) {
if params == nil {
params = &CreateModelCardInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateModelCard", params, optFns, c.addOperationCreateModelCardMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateModelCardOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateModelCardInput struct {
// The content of the model card. Content must be in model card JSON schema (https://docs.aws.amazon.com/sagemaker/latest/dg/model-cards.html#model-cards-json-schema)
// and provided as a string.
//
// This member is required.
Content *string
// The unique name of the model card.
//
// This member is required.
ModelCardName *string
// The approval status of the model card within your organization. Different
// organizations might have different criteria for model card review and approval.
// - Draft : The model card is a work in progress.
// - PendingReview : The model card is pending review.
// - Approved : The model card is approved.
// - Archived : The model card is archived. No more updates should be made to the
// model card, but it can still be exported.
//
// This member is required.
ModelCardStatus types.ModelCardStatus
// An optional Key Management Service key to encrypt, decrypt, and re-encrypt
// model card content for regulated workloads with highly sensitive data.
SecurityConfig *types.ModelCardSecurityConfig
// Key-value pairs used to manage metadata for model cards.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateModelCardOutput struct {
// The Amazon Resource Name (ARN) of the successfully created model card.
//
// This member is required.
ModelCardArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateModelCardMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateModelCard{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateModelCard{}, 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 = addOpCreateModelCardValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateModelCard(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateModelCard(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateModelCard",
}
}
| 153 |
aws-sdk-go-v2 | aws | Go | // 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 Model Card export job.
func (c *Client) CreateModelCardExportJob(ctx context.Context, params *CreateModelCardExportJobInput, optFns ...func(*Options)) (*CreateModelCardExportJobOutput, error) {
if params == nil {
params = &CreateModelCardExportJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateModelCardExportJob", params, optFns, c.addOperationCreateModelCardExportJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateModelCardExportJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateModelCardExportJobInput struct {
// The name of the model card export job.
//
// This member is required.
ModelCardExportJobName *string
// The name of the model card to export.
//
// This member is required.
ModelCardName *string
// The model card output configuration that specifies the Amazon S3 path for
// exporting.
//
// This member is required.
OutputConfig *types.ModelCardExportOutputConfig
// The version of the model card to export. If a version is not provided, then the
// latest version of the model card is exported.
ModelCardVersion int32
noSmithyDocumentSerde
}
type CreateModelCardExportJobOutput struct {
// The Amazon Resource Name (ARN) of the model card export job.
//
// This member is required.
ModelCardExportJobArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateModelCardExportJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateModelCardExportJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateModelCardExportJob{}, 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 = addOpCreateModelCardExportJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateModelCardExportJob(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateModelCardExportJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateModelCardExportJob",
}
}
| 142 |
aws-sdk-go-v2 | aws | Go | // 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateModelExplainabilityJobDefinition(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateModelExplainabilityJobDefinition",
}
}
| 169 |
aws-sdk-go-v2 | aws | Go | // 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 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 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 {
// An array of additional Inference Specification objects. Each additional
// Inference Specification specifies artifacts based on this model package that can
// be used on inference endpoints. Generally used with SageMaker Neo to store the
// compiled artifacts.
AdditionalInferenceSpecifications []types.AdditionalInferenceSpecificationDefinition
// 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
// The metadata properties associated with the model package versions.
CustomerMetadataProperties map[string]string
// The machine learning domain of your model package and its components. Common
// machine learning domains include computer vision and natural language
// processing.
Domain *string
// Represents the drift check baselines that can be used when the model monitor is
// set using the model package. For more information, see the topic on Drift
// Detection against Previous Baselines in SageMaker Pipelines (https://docs.aws.amazon.com/sagemaker/latest/dg/pipelines-quality-clarify-baseline-lifecycle.html#pipelines-quality-clarify-baseline-drift-detection)
// in the Amazon SageMaker Developer Guide.
DriftCheckBaselines *types.DriftCheckBaselines
// 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 or Amazon Resource Name (ARN) of the model package 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
// The Amazon Simple Storage Service (Amazon S3) path where the sample payload is
// stored. This path must point to a single gzip compressed tar archive (.tar.gz
// suffix). This archive can hold multiple files that are all equally used in the
// load test. Each file in the archive must satisfy the size constraints of the
// InvokeEndpoint (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html#API_runtime_InvokeEndpoint_RequestSyntax)
// call.
SamplePayloadUrl *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
// The machine learning task your model package accomplishes. Common machine
// learning tasks include object detection and image classification. The following
// tasks are supported by Inference Recommender: "IMAGE_CLASSIFICATION" |
// "OBJECT_DETECTION" | "TEXT_GENERATION" | "IMAGE_SEGMENTATION" | "FILL_MASK" |
// "CLASSIFICATION" | "REGRESSION" | "OTHER" . Specify "OTHER" if none of the tasks
// listed fit your use case.
Task *string
// Specifies configurations for one or more transform jobs that 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
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",
}
}
| 259 |
aws-sdk-go-v2 | aws | Go | // 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateModelPackageGroup(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateModelPackageGroup",
}
}
| 135 |
aws-sdk-go-v2 | aws | Go | // 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateModelQualityJobDefinition(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateModelQualityJobDefinition",
}
}
| 169 |
aws-sdk-go-v2 | aws | Go | // 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 Endpoint.
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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateMonitoringSchedule(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateMonitoringSchedule",
}
}
| 140 |
aws-sdk-go-v2 | aws | Go | // 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 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. 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. SageMaker also provides a set of example
// notebooks. Each notebook demonstrates how to use SageMaker with a specific
// algorithm or with a machine learning framework. After receiving the request,
// SageMaker does the following:
// - Creates a network interface in the SageMaker VPC.
// - (Option) If you specified SubnetId , 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, 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
// SageMaker VPC. If you specified SubnetId of your VPC, 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, SageMaker returns its Amazon Resource
// Name (ARN). You can't change the name of a notebook instance after you create
// it. After 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 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, SageMaker assumes this role to perform tasks on your behalf. You must
// grant this role necessary permissions so SageMaker can perform these tasks. The
// policy must allow the SageMaker service principal (sagemaker.amazonaws.com)
// permissions to assume this role. For more information, see SageMaker Roles (https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html)
// . To be able to pass this role to 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 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 SageMaker Notebook Instances (https://docs.aws.amazon.com/sagemaker/latest/dg/nbi-git-repo.html)
// .
DefaultCodeRepository *string
// Sets whether 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 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
// Information on the IMDS configuration of the notebook instance
InstanceMetadataServiceConfiguration *types.InstanceMetadataServiceConfiguration
// The Amazon Resource Name (ARN) of a Amazon Web Services Key Management Service
// key that 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateNotebookInstance(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateNotebookInstance",
}
}
| 248 |
aws-sdk-go-v2 | aws | Go | // 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateNotebookInstanceLifecycleConfig(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateNotebookInstanceLifecycleConfig",
}
}
| 146 |
aws-sdk-go-v2 | aws | Go | // 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 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
// This is the configuration that controls the parallelism of the pipeline. If
// specified, it applies to all runs of this pipeline by default.
ParallelismConfiguration *types.ParallelismConfiguration
// The JSON pipeline definition (https://aws-sagemaker-mlops.github.io/sagemaker-model-building-pipeline-definition-JSON-schema/)
// of the pipeline.
PipelineDefinition *string
// The location of the pipeline definition stored in Amazon S3. If specified,
// SageMaker will retrieve the pipeline definition from this location.
PipelineDefinitionS3Location *types.PipelineDefinitionS3Location
// 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
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",
}
}
| 195 |
aws-sdk-go-v2 | aws | Go | // 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 passed to 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
// The name of the space.
SpaceName *string
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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreatePresignedDomainUrl(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreatePresignedDomainUrl",
}
}
| 154 |
aws-sdk-go-v2 | aws | Go | // 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 SageMaker console, when you choose Open next to a notebook
// instance, 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 (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreatePresignedNotebookInstanceUrl.html)
// 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreatePresignedNotebookInstanceUrl(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreatePresignedNotebookInstanceUrl",
}
}
| 143 |
aws-sdk-go-v2 | aws | Go | // 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 (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateProcessingJob.html)
// - CreateTrainingJob (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)
// - CreateTransformJob (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html)
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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateProcessingJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateProcessingJob",
}
}
| 177 |
aws-sdk-go-v2 | aws | Go | // 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. The
// provisioning artifact ID will default to the latest provisioning artifact ID of
// the product, if you don't provide the provisioning artifact ID. For more
// 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateProject(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateProject",
}
}
| 151 |
aws-sdk-go-v2 | aws | Go | // 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 space used for real time collaboration in a Domain.
func (c *Client) CreateSpace(ctx context.Context, params *CreateSpaceInput, optFns ...func(*Options)) (*CreateSpaceOutput, error) {
if params == nil {
params = &CreateSpaceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "CreateSpace", params, optFns, c.addOperationCreateSpaceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*CreateSpaceOutput)
out.ResultMetadata = metadata
return out, nil
}
type CreateSpaceInput struct {
// The ID of the associated Domain.
//
// This member is required.
DomainId *string
// The name of the space.
//
// This member is required.
SpaceName *string
// A collection of space settings.
SpaceSettings *types.SpaceSettings
// Tags to associated with the space. Each tag consists of a key and an optional
// value. Tag keys must be unique for each resource. Tags are searchable using the
// Search API.
Tags []types.Tag
noSmithyDocumentSerde
}
type CreateSpaceOutput struct {
// The space's Amazon Resource Name (ARN).
SpaceArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationCreateSpaceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateSpace{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateSpace{}, 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 = addOpCreateSpaceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateSpace(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateSpace(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateSpace",
}
}
| 138 |
aws-sdk-go-v2 | aws | Go | // 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateStudioLifecycleConfig(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateStudioLifecycleConfig",
}
}
| 141 |
aws-sdk-go-v2 | aws | Go | // 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, SageMaker saves the
// resulting model artifacts to an Amazon S3 location that you specify. If you
// choose to host your model using 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 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 SageMaker, see Algorithms (https://docs.aws.amazon.com/sagemaker/latest/dg/algos.html)
// . Do not include any security-sensitive information including account access
// IDs, secrets or tokens in any hyperparameter field. If the use of
// security-sensitive credentials are detected, SageMaker will reject your training
// job request and return an exception error.
// - InputDataConfig - Describes the input required by the training job and the
// Amazon S3, EFS, or FSx location where it is stored.
// - OutputDataConfig - Identifies the Amazon S3 bucket where you want 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 SageMaker assumes to perform
// tasks on your behalf during model training. You must grant this role the
// necessary permissions so that 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 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 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.
// 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 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 SageMaker can assume to
// perform tasks on your behalf. During model training, 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
// SageMaker Roles (https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html)
// . To be able to pass this role to 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, SageMaker ends the training job. Use this API to cap model training
// costs. To stop a job, 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 Amazon SageMaker 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 Amazon SageMaker 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, 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 (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateProcessingJob.html)
// - CreateTrainingJob (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)
// - CreateTransformJob (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html)
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 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 . Do not include any security-sensitive information including
// account access IDs, secrets or tokens in any hyperparameter field. If the use of
// security-sensitive credentials are detected, SageMaker will reject your training
// job request and return an exception error.
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, 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 are available as input streams. They do not need to
// be downloaded. Your input must be in the same Amazon Web Services region as your
// training job.
InputDataConfig []types.Channel
// Configuration information for Amazon SageMaker Debugger system monitoring,
// framework profiling, and storage paths.
ProfilerConfig *types.ProfilerConfig
// Configuration information for Amazon SageMaker 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 Amazon SageMaker Debugger
// TensorBoard output data.
TensorBoardOutputConfig *types.TensorBoardOutputConfig
// A VpcConfig (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_VpcConfig.html)
// 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateTrainingJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateTrainingJob",
}
}
| 323 |
aws-sdk-go-v2 | aws | Go | // 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 (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)
// .
// - 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
// Configuration to control how SageMaker captures inference data.
DataCaptureConfig *types.BatchDataCaptureConfig
// 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 (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateProcessingJob.html)
// - CreateTrainingJob (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)
// - CreateTransformJob (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html)
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. The value of MaxPayloadInMB cannot be
// greater than 100 MB. If you specify the MaxConcurrentTransforms parameter, the
// value of (MaxConcurrentTransforms * MaxPayloadInMB) also cannot exceed 100 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateTransformJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateTransformJob",
}
}
| 238 |
aws-sdk-go-v2 | aws | Go | // 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 (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Search.html)
// API to search for the tags. To get a list of all your trials, call the
// ListTrials (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListTrials.html)
// API. To view a trial's properties, call the DescribeTrial (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeTrial.html)
// API. To create a trial component, call the CreateTrialComponent (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrialComponent.html)
// 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 (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Search.html)
// 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateTrial(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateTrial",
}
}
| 153 |
aws-sdk-go-v2 | aws | Go | // 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 (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Search.html)
// 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 (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Search.html)
// 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateTrialComponent(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateTrialComponent",
}
}
| 169 |
aws-sdk-go-v2 | aws | Go | // 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 IAM Identity Center, 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
// IAM Identity Center, this field is required. If the Domain's AuthMode is not IAM
// Identity Center, 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 IAM Identity Center, this field is
// required, and must match a valid username of a user in your directory. If the
// Domain's AuthMode is not IAM Identity Center, 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateUserProfile(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateUserProfile",
}
}
| 157 |
aws-sdk-go-v2 | aws | Go | // 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
// DeleteWorkforce (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteWorkforce.html)
// 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
// Use this parameter to configure a workforce using VPC.
WorkforceVpcConfig *types.WorkforceVpcConfigRequest
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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateWorkforce(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateWorkforce",
}
}
| 167 |
aws-sdk-go-v2 | aws | Go | // 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opCreateWorkteam(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "CreateWorkteam",
}
}
| 164 |
aws-sdk-go-v2 | aws | Go | // 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteAction(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteAction",
}
}
| 124 |
aws-sdk-go-v2 | aws | Go | // 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteAlgorithm(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteAlgorithm",
}
}
| 120 |
aws-sdk-go-v2 | aws | Go | // 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 name of the space. If this value is not set, then UserProfileName must be
// set.
SpaceName *string
// The user profile name. If this value is not set, then SpaceName must be set.
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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteApp(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteApp",
}
}
| 138 |
aws-sdk-go-v2 | aws | Go | // 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteAppImageConfig(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteAppImageConfig",
}
}
| 120 |
aws-sdk-go-v2 | aws | Go | // 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteArtifact(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteArtifact",
}
}
| 126 |
aws-sdk-go-v2 | aws | Go | // 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteAssociation(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteAssociation",
}
}
| 132 |
aws-sdk-go-v2 | aws | Go | // 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteCodeRepository(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteCodeRepository",
}
}
| 120 |
aws-sdk-go-v2 | aws | Go | // 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteContext(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteContext",
}
}
| 124 |
aws-sdk-go-v2 | aws | Go | // 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteDataQualityJobDefinition(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteDataQualityJobDefinition",
}
}
| 120 |
aws-sdk-go-v2 | aws | Go | // 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteDeviceFleet(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteDeviceFleet",
}
}
| 120 |
aws-sdk-go-v2 | aws | Go | // 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 IAM Identity Center. 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteDomain(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteDomain",
}
}
| 129 |
aws-sdk-go-v2 | aws | Go | // 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 edge deployment plan if (and only if) all the stages in the plan are
// inactive or there are no stages in the plan.
func (c *Client) DeleteEdgeDeploymentPlan(ctx context.Context, params *DeleteEdgeDeploymentPlanInput, optFns ...func(*Options)) (*DeleteEdgeDeploymentPlanOutput, error) {
if params == nil {
params = &DeleteEdgeDeploymentPlanInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteEdgeDeploymentPlan", params, optFns, c.addOperationDeleteEdgeDeploymentPlanMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteEdgeDeploymentPlanOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteEdgeDeploymentPlanInput struct {
// The name of the edge deployment plan to delete.
//
// This member is required.
EdgeDeploymentPlanName *string
noSmithyDocumentSerde
}
type DeleteEdgeDeploymentPlanOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteEdgeDeploymentPlanMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteEdgeDeploymentPlan{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteEdgeDeploymentPlan{}, 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 = addOpDeleteEdgeDeploymentPlanValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteEdgeDeploymentPlan(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteEdgeDeploymentPlan(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteEdgeDeploymentPlan",
}
}
| 121 |
aws-sdk-go-v2 | aws | Go | // 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 a stage in an edge deployment plan if (and only if) the stage is
// inactive.
func (c *Client) DeleteEdgeDeploymentStage(ctx context.Context, params *DeleteEdgeDeploymentStageInput, optFns ...func(*Options)) (*DeleteEdgeDeploymentStageOutput, error) {
if params == nil {
params = &DeleteEdgeDeploymentStageInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteEdgeDeploymentStage", params, optFns, c.addOperationDeleteEdgeDeploymentStageMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteEdgeDeploymentStageOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteEdgeDeploymentStageInput struct {
// The name of the edge deployment plan from which the stage will be deleted.
//
// This member is required.
EdgeDeploymentPlanName *string
// The name of the stage.
//
// This member is required.
StageName *string
noSmithyDocumentSerde
}
type DeleteEdgeDeploymentStageOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteEdgeDeploymentStageMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteEdgeDeploymentStage{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteEdgeDeploymentStage{}, 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 = addOpDeleteEdgeDeploymentStageValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteEdgeDeploymentStage(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteEdgeDeploymentStage(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteEdgeDeploymentStage",
}
}
| 126 |
aws-sdk-go-v2 | aws | Go | // 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. SageMaker frees up all of the resources that were deployed
// when the endpoint was created. 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. When you delete your endpoint, SageMaker asynchronously deletes
// associated endpoint resources such as KMS key grants. You might still see these
// resources in your account for a few minutes after deleting your endpoint. Do not
// delete or revoke the permissions for your ExecutionRoleArn (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html#sagemaker-CreateModel-request-ExecutionRoleArn)
// , otherwise SageMaker cannot delete these resources.
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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteEndpoint(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteEndpoint",
}
}
| 127 |
aws-sdk-go-v2 | aws | Go | // 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteEndpointConfig(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteEndpointConfig",
}
}
| 127 |
aws-sdk-go-v2 | aws | Go | // 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 (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListTrials.html)
// 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteExperiment(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteExperiment",
}
}
| 126 |
aws-sdk-go-v2 | aws | Go | // 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteFeatureGroup(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteFeatureGroup",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteFlowDefinition(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteFlowDefinition",
}
}
| 120 |
aws-sdk-go-v2 | aws | Go | // 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 a hub. Hub APIs are only callable through SageMaker Studio.
func (c *Client) DeleteHub(ctx context.Context, params *DeleteHubInput, optFns ...func(*Options)) (*DeleteHubOutput, error) {
if params == nil {
params = &DeleteHubInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteHub", params, optFns, c.addOperationDeleteHubMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteHubOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteHubInput struct {
// The name of the hub to delete.
//
// This member is required.
HubName *string
noSmithyDocumentSerde
}
type DeleteHubOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteHubMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteHub{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteHub{}, 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 = addOpDeleteHubValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteHub(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteHub(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteHub",
}
}
| 120 |
aws-sdk-go-v2 | aws | Go | // 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"
)
// Delete the contents of a hub. Hub APIs are only callable through SageMaker
// Studio.
func (c *Client) DeleteHubContent(ctx context.Context, params *DeleteHubContentInput, optFns ...func(*Options)) (*DeleteHubContentOutput, error) {
if params == nil {
params = &DeleteHubContentInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteHubContent", params, optFns, c.addOperationDeleteHubContentMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteHubContentOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteHubContentInput struct {
// The name of the content that you want to delete from a hub.
//
// This member is required.
HubContentName *string
// The type of content that you want to delete from a hub.
//
// This member is required.
HubContentType types.HubContentType
// The version of the content that you want to delete from a hub.
//
// This member is required.
HubContentVersion *string
// The name of the hub that you want to delete content in.
//
// This member is required.
HubName *string
noSmithyDocumentSerde
}
type DeleteHubContentOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteHubContentMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteHubContent{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteHubContent{}, 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 = addOpDeleteHubContentValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteHubContent(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteHubContent(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteHubContent",
}
}
| 137 |
aws-sdk-go-v2 | aws | Go | // 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 ListHumanTaskUis (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListHumanTaskUis.html)
// . 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteHumanTaskUi(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteHumanTaskUi",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteImage(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteImage",
}
}
| 121 |
aws-sdk-go-v2 | aws | Go | // 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 to delete.
//
// This member is required.
ImageName *string
// The alias of the image to delete.
Alias *string
// The version to delete.
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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteImageVersion(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteImageVersion",
}
}
| 127 |
aws-sdk-go-v2 | aws | Go | // 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 inference experiment. This operation does not delete your endpoint,
// variants, or any underlying resources. This operation only deletes the metadata
// of your experiment.
func (c *Client) DeleteInferenceExperiment(ctx context.Context, params *DeleteInferenceExperimentInput, optFns ...func(*Options)) (*DeleteInferenceExperimentOutput, error) {
if params == nil {
params = &DeleteInferenceExperimentInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteInferenceExperiment", params, optFns, c.addOperationDeleteInferenceExperimentMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteInferenceExperimentOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteInferenceExperimentInput struct {
// The name of the inference experiment you want to delete.
//
// This member is required.
Name *string
noSmithyDocumentSerde
}
type DeleteInferenceExperimentOutput struct {
// The ARN of the deleted inference experiment.
//
// This member is required.
InferenceExperimentArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteInferenceExperimentMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteInferenceExperiment{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteInferenceExperiment{}, 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 = addOpDeleteInferenceExperimentValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteInferenceExperiment(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteInferenceExperiment(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteInferenceExperiment",
}
}
| 128 |
aws-sdk-go-v2 | aws | Go | // 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 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteModel(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteModel",
}
}
| 123 |
aws-sdk-go-v2 | aws | Go | // 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteModelBiasJobDefinition(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteModelBiasJobDefinition",
}
}
| 120 |
aws-sdk-go-v2 | aws | Go | // 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 Card.
func (c *Client) DeleteModelCard(ctx context.Context, params *DeleteModelCardInput, optFns ...func(*Options)) (*DeleteModelCardOutput, error) {
if params == nil {
params = &DeleteModelCardInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteModelCard", params, optFns, c.addOperationDeleteModelCardMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteModelCardOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteModelCardInput struct {
// The name of the model card to delete.
//
// This member is required.
ModelCardName *string
noSmithyDocumentSerde
}
type DeleteModelCardOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteModelCardMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteModelCard{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteModelCard{}, 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 = addOpDeleteModelCardValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteModelCard(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteModelCard(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteModelCard",
}
}
| 120 |
aws-sdk-go-v2 | aws | Go | // 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteModelExplainabilityJobDefinition(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteModelExplainabilityJobDefinition",
}
}
| 120 |
aws-sdk-go-v2 | aws | Go | // 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 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 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteModelPackage(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteModelPackage",
}
}
| 124 |
aws-sdk-go-v2 | aws | Go | // 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteModelPackageGroup(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteModelPackageGroup",
}
}
| 120 |
aws-sdk-go-v2 | aws | Go | // 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteModelPackageGroupPolicy(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteModelPackageGroupPolicy",
}
}
| 120 |
aws-sdk-go-v2 | aws | Go | // 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteModelQualityJobDefinition(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteModelQualityJobDefinition",
}
}
| 120 |
aws-sdk-go-v2 | aws | Go | // 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteMonitoringSchedule(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteMonitoringSchedule",
}
}
| 122 |
aws-sdk-go-v2 | aws | Go | // 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 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. 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 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteNotebookInstance(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteNotebookInstance",
}
}
| 124 |
aws-sdk-go-v2 | aws | Go | // 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteNotebookInstanceLifecycleConfig(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteNotebookInstanceLifecycleConfig",
}
}
| 120 |
aws-sdk-go-v2 | aws | Go | // 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
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",
}
}
| 170 |
aws-sdk-go-v2 | aws | Go | // 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteProject(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteProject",
}
}
| 120 |
aws-sdk-go-v2 | aws | Go | // 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"
)
// Used to delete a space.
func (c *Client) DeleteSpace(ctx context.Context, params *DeleteSpaceInput, optFns ...func(*Options)) (*DeleteSpaceOutput, error) {
if params == nil {
params = &DeleteSpaceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DeleteSpace", params, optFns, c.addOperationDeleteSpaceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DeleteSpaceOutput)
out.ResultMetadata = metadata
return out, nil
}
type DeleteSpaceInput struct {
// The ID of the associated Domain.
//
// This member is required.
DomainId *string
// The name of the space.
//
// This member is required.
SpaceName *string
noSmithyDocumentSerde
}
type DeleteSpaceOutput struct {
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDeleteSpaceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDeleteSpace{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDeleteSpace{}, 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 = addOpDeleteSpaceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDeleteSpace(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteSpace(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteSpace",
}
}
| 125 |
aws-sdk-go-v2 | aws | Go | // 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteStudioLifecycleConfig(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteStudioLifecycleConfig",
}
}
| 123 |
aws-sdk-go-v2 | aws | Go | // 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 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteTags(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteTags",
}
}
| 131 |
aws-sdk-go-v2 | aws | Go | // 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 (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeTrialComponent.html)
// 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteTrial(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteTrial",
}
}
| 126 |
aws-sdk-go-v2 | aws | Go | // 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 (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DisassociateTrialComponent.html)
// 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteTrialComponent(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteTrialComponent",
}
}
| 127 |
aws-sdk-go-v2 | aws | Go | // 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteUserProfile(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteUserProfile",
}
}
| 126 |
aws-sdk-go-v2 | aws | Go | // 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 CreateWorkforce (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateWorkforce.html)
// to create a new workforce. If a private workforce contains one or more work
// teams, you must use the DeleteWorkteam (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteWorkteam.html)
// 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteWorkforce(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteWorkforce",
}
}
| 127 |
aws-sdk-go-v2 | aws | Go | // 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeleteWorkteam(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeleteWorkteam",
}
}
| 127 |
aws-sdk-go-v2 | aws | Go | // 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDeregisterDevices(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DeregisterDevices",
}
}
| 126 |
aws-sdk-go-v2 | aws | Go | // 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, lineage group, project, or model card.
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, lineage group, project, or model card.
LastModifiedBy *types.UserContext
// When the action was last modified.
LastModifiedTime *time.Time
// The Amazon Resource Name (ARN) of the lineage group.
LineageGroupArn *string
// 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeAction(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DescribeAction",
}
}
| 164 |
aws-sdk-go-v2 | aws | Go | // 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 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeAlgorithm(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DescribeAlgorithm",
}
}
| 170 |
aws-sdk-go-v2 | aws | Go | // 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 name of the space.
SpaceName *string
// The user profile name. If this value is not set, then SpaceName must be set.
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 is also
// updated when SageMaker performs health checks without user activity. As a
// result, this value is set to the same value as LastHealthCheckTimestamp .
LastUserActivityTimestamp *time.Time
// The instance type and the Amazon Resource Name (ARN) of the SageMaker image
// created on the instance.
ResourceSpec *types.ResourceSpec
// The name of the space. If this value is not set, then UserProfileName must be
// set.
SpaceName *string
// 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeApp(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DescribeApp",
}
}
| 179 |
aws-sdk-go-v2 | aws | Go | // 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeAppImageConfig(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DescribeAppImageConfig",
}
}
| 138 |
aws-sdk-go-v2 | aws | Go | // 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, lineage group, project, or model card.
CreatedBy *types.UserContext
// When the artifact was created.
CreationTime *time.Time
// Information about the user who created or modified an experiment, trial, trial
// component, lineage group, project, or model card.
LastModifiedBy *types.UserContext
// When the artifact was last modified.
LastModifiedTime *time.Time
// The Amazon Resource Name (ARN) of the lineage group.
LineageGroupArn *string
// 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeArtifact(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DescribeArtifact",
}
}
| 158 |
aws-sdk-go-v2 | aws | Go | // 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 AutoML job created by calling CreateAutoMLJob (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateAutoMLJob.html)
// . AutoML jobs created by calling CreateAutoMLJobV2 (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateAutoMLJobV2.html)
// cannot be described by DescribeAutoMLJob .
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 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
// The best model candidate selected by SageMaker Autopilot using both the best
// objective metric and lowest InferenceLatency (https://docs.aws.amazon.com/sagemaker/latest/dg/autopilot-metrics-validation.html)
// for an experiment.
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
// Contains ProblemType , AutoMLJobObjective , and CompletionCriteria . If you do
// not provide these values, they are inferred.
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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeAutoMLJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DescribeAutoMLJob",
}
}
| 213 |
aws-sdk-go-v2 | aws | Go | // 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 AutoML job created by calling CreateAutoMLJobV2 (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateAutoMLJobV2.html)
// or CreateAutoMLJob (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateAutoMLJob.html)
// .
func (c *Client) DescribeAutoMLJobV2(ctx context.Context, params *DescribeAutoMLJobV2Input, optFns ...func(*Options)) (*DescribeAutoMLJobV2Output, error) {
if params == nil {
params = &DescribeAutoMLJobV2Input{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeAutoMLJobV2", params, optFns, c.addOperationDescribeAutoMLJobV2Middlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeAutoMLJobV2Output)
out.ResultMetadata = metadata
return out, nil
}
type DescribeAutoMLJobV2Input struct {
// Requests information about an AutoML job V2 using its unique name.
//
// This member is required.
AutoMLJobName *string
noSmithyDocumentSerde
}
type DescribeAutoMLJobV2Output struct {
// Returns the Amazon Resource Name (ARN) of the AutoML job V2.
//
// This member is required.
AutoMLJobArn *string
// Returns an array of channel objects describing the input data and their
// location.
//
// This member is required.
AutoMLJobInputDataConfig []types.AutoMLJobChannel
// Returns the name of the AutoML job V2.
//
// This member is required.
AutoMLJobName *string
// Returns the secondary status of the AutoML job V2.
//
// This member is required.
AutoMLJobSecondaryStatus types.AutoMLJobSecondaryStatus
// Returns the status of the AutoML job V2.
//
// This member is required.
AutoMLJobStatus types.AutoMLJobStatus
// Returns the creation time of the AutoML job V2.
//
// This member is required.
CreationTime *time.Time
// 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 ARN of the Identity and Access Management 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
// The artifacts that are generated during an AutoML job.
AutoMLJobArtifacts *types.AutoMLJobArtifacts
// Returns the job's objective.
AutoMLJobObjective *types.AutoMLJobObjective
// Returns the configuration settings of the problem type set for the AutoML job
// V2.
AutoMLProblemTypeConfig types.AutoMLProblemTypeConfig
// Returns the name of the problem type configuration set for the AutoML job V2.
AutoMLProblemTypeConfigName types.AutoMLProblemTypeConfigName
// Information about the candidate produced by an AutoML training job V2,
// including its status, steps, and other properties.
BestCandidate *types.AutoMLCandidate
// Returns the configuration settings of how the data are split into train and
// validation datasets.
DataSplitConfig *types.AutoMLDataSplitConfig
// Returns the end time of the AutoML job V2.
EndTime *time.Time
// Returns the reason for the failure of the AutoML job V2, when applicable.
FailureReason *string
// 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 V2.
PartialFailureReasons []types.AutoMLPartialFailureReason
// Returns the resolved attributes used by the AutoML job V2.
ResolvedAttributes *types.AutoMLResolvedAttributes
// Returns the security configuration for traffic encryption or Amazon VPC
// settings.
SecurityConfig *types.AutoMLSecurityConfig
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeAutoMLJobV2Middlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeAutoMLJobV2{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeAutoMLJobV2{}, 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 = addOpDescribeAutoMLJobV2ValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeAutoMLJobV2(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeAutoMLJobV2(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DescribeAutoMLJobV2",
}
}
| 217 |
aws-sdk-go-v2 | aws | Go | // 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeCodeRepository(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DescribeCodeRepository",
}
}
| 149 |
aws-sdk-go-v2 | aws | Go | // 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 (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateCompilationJob.html)
// . To get information about multiple model compilation jobs, use
// ListCompilationJobs (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListCompilationJobs.html)
// .
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
// 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
// The Amazon Resource Name (ARN) of the versioned model package that was provided
// to SageMaker Neo when you initiated a compilation job.
ModelPackageVersionArn *string
// A VpcConfig (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_VpcConfig.html)
// 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeCompilationJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DescribeCompilationJob",
}
}
| 221 |
aws-sdk-go-v2 | aws | Go | // 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, lineage group, project, or model card.
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, lineage group, project, or model card.
LastModifiedBy *types.UserContext
// When the context was last modified.
LastModifiedTime *time.Time
// The Amazon Resource Name (ARN) of the lineage group.
LineageGroupArn *string
// 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeContext(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DescribeContext",
}
}
| 158 |
aws-sdk-go-v2 | aws | Go | // 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 = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeDataQualityJobDefinition(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DescribeDataQualityJobDefinition",
}
}
| 174 |
aws-sdk-go-v2 | aws | Go | // 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 device.
func (c *Client) DescribeDevice(ctx context.Context, params *DescribeDeviceInput, optFns ...func(*Options)) (*DescribeDeviceOutput, error) {
if params == nil {
params = &DescribeDeviceInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeDevice", params, optFns, c.addOperationDescribeDeviceMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeDeviceOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeDeviceInput struct {
// The name of the fleet the devices belong to.
//
// This member is required.
DeviceFleetName *string
// The unique ID of the device.
//
// This member is required.
DeviceName *string
// Next token of device description.
NextToken *string
noSmithyDocumentSerde
}
type DescribeDeviceOutput struct {
// The name of the fleet the device belongs to.
//
// This member is required.
DeviceFleetName *string
// The unique identifier of the device.
//
// This member is required.
DeviceName *string
// The timestamp of the last registration or de-reregistration.
//
// This member is required.
RegistrationTime *time.Time
// Edge Manager agent version.
AgentVersion *string
// A description of the device.
Description *string
// The Amazon Resource Name (ARN) of the device.
DeviceArn *string
// The Amazon Web Services Internet of Things (IoT) object thing name associated
// with the device.
IotThingName *string
// The last heartbeat received from the device.
LatestHeartbeat *time.Time
// The maximum number of models.
MaxModels int32
// Models on the device.
Models []types.EdgeModel
// The response from the last list when returning a list large enough to need
// tokening.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeDeviceMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeDevice{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeDevice{}, 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 = addOpDescribeDeviceValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeDevice(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeDevice(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DescribeDevice",
}
}
| 172 |
aws-sdk-go-v2 | aws | Go | // 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"
)
// A description of the fleet the device belongs to.
func (c *Client) DescribeDeviceFleet(ctx context.Context, params *DescribeDeviceFleetInput, optFns ...func(*Options)) (*DescribeDeviceFleetOutput, error) {
if params == nil {
params = &DescribeDeviceFleetInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeDeviceFleet", params, optFns, c.addOperationDescribeDeviceFleetMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeDeviceFleetOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeDeviceFleetInput struct {
// The name of the fleet.
//
// This member is required.
DeviceFleetName *string
noSmithyDocumentSerde
}
type DescribeDeviceFleetOutput struct {
// Timestamp of when the device fleet was created.
//
// This member is required.
CreationTime *time.Time
// The The Amazon Resource Name (ARN) of the fleet.
//
// This member is required.
DeviceFleetArn *string
// The name of the fleet.
//
// This member is required.
DeviceFleetName *string
// Timestamp of when the device fleet was last updated.
//
// This member is required.
LastModifiedTime *time.Time
// The output configuration for storing sampled data.
//
// This member is required.
OutputConfig *types.EdgeOutputConfig
// A description of the fleet.
Description *string
// The Amazon Resource Name (ARN) alias created in Amazon Web Services Internet of
// Things (IoT).
IotRoleAlias *string
// The Amazon Resource Name (ARN) that has access to Amazon Web Services Internet
// of Things (IoT).
RoleArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeDeviceFleetMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeDeviceFleet{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeDeviceFleet{}, 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 = addOpDescribeDeviceFleetValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeDeviceFleet(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeDeviceFleet(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DescribeDeviceFleet",
}
}
| 159 |
aws-sdk-go-v2 | aws | Go | // 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"
)
// The description of the domain.
func (c *Client) DescribeDomain(ctx context.Context, params *DescribeDomainInput, optFns ...func(*Options)) (*DescribeDomainOutput, error) {
if params == nil {
params = &DescribeDomainInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeDomain", params, optFns, c.addOperationDescribeDomainMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeDomainOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeDomainInput struct {
// The domain ID.
//
// This member is required.
DomainId *string
noSmithyDocumentSerde
}
type DescribeDomainOutput struct {
// 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
// The entity that creates and manages the required security groups for inter-app
// communication in VPCOnly mode. Required when CreateDomain.AppNetworkAccessType
// is VPCOnly and
// DomainSettings.RStudioServerProDomainSettings.DomainExecutionRoleArn is provided.
AppSecurityGroupManagement types.AppSecurityGroupManagement
// The domain's authentication mode.
AuthMode types.AuthMode
// The creation time.
CreationTime *time.Time
// The default settings used to create a space.
DefaultSpaceSettings *types.DefaultSpaceSettings
// Settings which are applied to UserProfiles in this domain if settings are not
// explicitly specified in a given UserProfile.
DefaultUserSettings *types.UserSettings
// The domain's Amazon Resource Name (ARN).
DomainArn *string
// The domain ID.
DomainId *string
// The domain name.
DomainName *string
// A collection of Domain settings.
DomainSettings *types.DomainSettings
// The failure reason.
FailureReason *string
// The ID of the Amazon Elastic File System (EFS) managed by this Domain.
HomeEfsFileSystemId *string
// Use KmsKeyId .
//
// Deprecated: This property is deprecated, use KmsKeyId instead.
HomeEfsFileSystemKmsKeyId *string
// The Amazon Web Services KMS customer managed key used to encrypt the EFS volume
// attached to the domain.
KmsKeyId *string
// The last modified time.
LastModifiedTime *time.Time
// The ID of the security group that authorizes traffic between the RSessionGateway
// apps and the RStudioServerPro app.
SecurityGroupIdForDomainBoundary *string
// The IAM Identity Center managed application instance ID.
SingleSignOnManagedApplicationInstanceId *string
// The status.
Status types.DomainStatus
// The VPC subnets that Studio uses for communication.
SubnetIds []string
// The domain's URL.
Url *string
// The ID of the Amazon Virtual Private Cloud (VPC) that Studio uses for
// communication.
VpcId *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeDomainMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeDomain{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeDomain{}, 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 = addOpDescribeDomainValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeDomain(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeDomain(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DescribeDomain",
}
}
| 199 |
aws-sdk-go-v2 | aws | Go | // 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 edge deployment plan with deployment status per stage.
func (c *Client) DescribeEdgeDeploymentPlan(ctx context.Context, params *DescribeEdgeDeploymentPlanInput, optFns ...func(*Options)) (*DescribeEdgeDeploymentPlanOutput, error) {
if params == nil {
params = &DescribeEdgeDeploymentPlanInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeEdgeDeploymentPlan", params, optFns, c.addOperationDescribeEdgeDeploymentPlanMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeEdgeDeploymentPlanOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeEdgeDeploymentPlanInput struct {
// The name of the deployment plan to describe.
//
// This member is required.
EdgeDeploymentPlanName *string
// The maximum number of results to select (50 by default).
MaxResults int32
// If the edge deployment plan has enough stages to require tokening, then this is
// the response from the last list of stages returned.
NextToken *string
noSmithyDocumentSerde
}
type DescribeEdgeDeploymentPlanOutput struct {
// The device fleet used for this edge deployment plan.
//
// This member is required.
DeviceFleetName *string
// The ARN of edge deployment plan.
//
// This member is required.
EdgeDeploymentPlanArn *string
// The name of the edge deployment plan.
//
// This member is required.
EdgeDeploymentPlanName *string
// List of models associated with the edge deployment plan.
//
// This member is required.
ModelConfigs []types.EdgeDeploymentModelConfig
// List of stages in the edge deployment plan.
//
// This member is required.
Stages []types.DeploymentStageStatusSummary
// The time when the edge deployment plan was created.
CreationTime *time.Time
// The number of edge devices that failed the deployment.
EdgeDeploymentFailed int32
// The number of edge devices yet to pick up deployment, or in progress.
EdgeDeploymentPending int32
// The number of edge devices with the successful deployment.
EdgeDeploymentSuccess int32
// The time when the edge deployment plan was last updated.
LastModifiedTime *time.Time
// Token to use when calling the next set of stages in the edge deployment plan.
NextToken *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeEdgeDeploymentPlanMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeEdgeDeploymentPlan{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeEdgeDeploymentPlan{}, 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 = addOpDescribeEdgeDeploymentPlanValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeEdgeDeploymentPlan(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeEdgeDeploymentPlan(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DescribeEdgeDeploymentPlan",
}
}
| 173 |
aws-sdk-go-v2 | aws | Go | // 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"
)
// A description of edge packaging jobs.
func (c *Client) DescribeEdgePackagingJob(ctx context.Context, params *DescribeEdgePackagingJobInput, optFns ...func(*Options)) (*DescribeEdgePackagingJobOutput, error) {
if params == nil {
params = &DescribeEdgePackagingJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeEdgePackagingJob", params, optFns, c.addOperationDescribeEdgePackagingJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeEdgePackagingJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeEdgePackagingJobInput struct {
// The name of the edge packaging job.
//
// This member is required.
EdgePackagingJobName *string
noSmithyDocumentSerde
}
type DescribeEdgePackagingJobOutput struct {
// The Amazon Resource Name (ARN) of the edge packaging job.
//
// This member is required.
EdgePackagingJobArn *string
// The name of the edge packaging job.
//
// This member is required.
EdgePackagingJobName *string
// The current status of the packaging job.
//
// This member is required.
EdgePackagingJobStatus types.EdgePackagingJobStatus
// The name of the SageMaker Neo compilation job that is used to locate model
// artifacts that are being packaged.
CompilationJobName *string
// The timestamp of when the packaging job was created.
CreationTime *time.Time
// Returns a message describing the job status and error messages.
EdgePackagingJobStatusMessage *string
// The timestamp of when the job was last updated.
LastModifiedTime *time.Time
// The Amazon Simple Storage (S3) URI where model artifacts ares stored.
ModelArtifact *string
// The name of the model.
ModelName *string
// The signature document of files in the model artifact.
ModelSignature *string
// The version of the model.
ModelVersion *string
// The output configuration for the edge packaging job.
OutputConfig *types.EdgeOutputConfig
// The output of a SageMaker Edge Manager deployable resource.
PresetDeploymentOutput *types.EdgePresetDeploymentOutput
// The Amazon Web Services KMS key to use when encrypting the EBS volume the job
// run on.
ResourceKey *string
// The Amazon Resource Name (ARN) of an IAM role that enables Amazon SageMaker to
// download and upload the model, and to contact Neo.
RoleArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeEdgePackagingJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeEdgePackagingJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeEdgePackagingJob{}, 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 = addOpDescribeEdgePackagingJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeEdgePackagingJob(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeEdgePackagingJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DescribeEdgePackagingJob",
}
}
| 177 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
"errors"
"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"
smithy "github.com/aws/smithy-go"
"github.com/aws/smithy-go/middleware"
smithytime "github.com/aws/smithy-go/time"
smithyhttp "github.com/aws/smithy-go/transport/http"
smithywaiter "github.com/aws/smithy-go/waiter"
"github.com/jmespath/go-jmespath"
"time"
)
// Returns the description of an endpoint.
func (c *Client) DescribeEndpoint(ctx context.Context, params *DescribeEndpointInput, optFns ...func(*Options)) (*DescribeEndpointOutput, error) {
if params == nil {
params = &DescribeEndpointInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeEndpoint", params, optFns, c.addOperationDescribeEndpointMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeEndpointOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeEndpointInput struct {
// The name of the endpoint.
//
// This member is required.
EndpointName *string
noSmithyDocumentSerde
}
type DescribeEndpointOutput struct {
// A timestamp that shows when the endpoint was created.
//
// This member is required.
CreationTime *time.Time
// The Amazon Resource Name (ARN) of the endpoint.
//
// This member is required.
EndpointArn *string
// The name of the endpoint configuration associated with this endpoint.
//
// This member is required.
EndpointConfigName *string
// Name of the endpoint.
//
// This member is required.
EndpointName *string
// The status of the endpoint.
// - OutOfService : Endpoint is not available to take incoming requests.
// - Creating : CreateEndpoint (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html)
// is executing.
// - Updating : UpdateEndpoint (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html)
// or UpdateEndpointWeightsAndCapacities (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpointWeightsAndCapacities.html)
// is executing.
// - SystemUpdating : Endpoint is undergoing maintenance and cannot be updated or
// deleted or re-scaled until it has completed. This maintenance operation does not
// change any customer-specified values such as VPC config, KMS encryption, model,
// instance type, or instance count.
// - RollingBack : Endpoint fails to scale up or down or change its variant
// weight and is in the process of rolling back to its previous configuration. Once
// the rollback completes, endpoint returns to an InService status. This
// transitional status only applies to an endpoint that has autoscaling enabled and
// is undergoing variant weight or capacity changes as part of an
// UpdateEndpointWeightsAndCapacities (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpointWeightsAndCapacities.html)
// call or when the UpdateEndpointWeightsAndCapacities (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpointWeightsAndCapacities.html)
// operation is called explicitly.
// - InService : Endpoint is available to process incoming requests.
// - Deleting : DeleteEndpoint (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpoint.html)
// is executing.
// - Failed : Endpoint could not be created, updated, or re-scaled. Use the
// FailureReason value returned by DescribeEndpoint (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html)
// for information about the failure. DeleteEndpoint (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpoint.html)
// is the only operation that can be performed on a failed endpoint.
//
// This member is required.
EndpointStatus types.EndpointStatus
// A timestamp that shows when the endpoint was last modified.
//
// This member is required.
LastModifiedTime *time.Time
// Returns the description of an endpoint configuration created using the
// CreateEndpointConfig (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html)
// API.
AsyncInferenceConfig *types.AsyncInferenceConfig
// The currently active data capture configuration used by your Endpoint.
DataCaptureConfig *types.DataCaptureConfigSummary
// The configuration parameters for an explainer.
ExplainerConfig *types.ExplainerConfig
// If the status of the endpoint is Failed , the reason why it failed.
FailureReason *string
// The most recent deployment configuration for the endpoint.
LastDeploymentConfig *types.DeploymentConfig
// Returns the summary of an in-progress deployment. This field is only returned
// when the endpoint is creating or updating with a new endpoint configuration.
PendingDeploymentSummary *types.PendingDeploymentSummary
// An array of ProductionVariantSummary (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariantSummary.html)
// objects, one for each model hosted behind this endpoint.
ProductionVariants []types.ProductionVariantSummary
// An array of ProductionVariantSummary (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariantSummary.html)
// objects, one for each model that you want to host at this endpoint in shadow
// mode with production traffic replicated from the model specified on
// ProductionVariants .
ShadowProductionVariants []types.ProductionVariantSummary
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeEndpointMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeEndpoint{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeEndpoint{}, 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 = addOpDescribeEndpointValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeEndpoint(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// DescribeEndpointAPIClient is a client that implements the DescribeEndpoint
// operation.
type DescribeEndpointAPIClient interface {
DescribeEndpoint(context.Context, *DescribeEndpointInput, ...func(*Options)) (*DescribeEndpointOutput, error)
}
var _ DescribeEndpointAPIClient = (*Client)(nil)
// EndpointDeletedWaiterOptions are waiter options for EndpointDeletedWaiter
type EndpointDeletedWaiterOptions 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
// MinDelay is the minimum amount of time to delay between retries. If unset,
// EndpointDeletedWaiter will use default minimum delay of 30 seconds. Note that
// MinDelay must resolve to a value lesser than or equal to the MaxDelay.
MinDelay time.Duration
// MaxDelay is the maximum amount of time to delay between retries. If unset or
// set to zero, EndpointDeletedWaiter will use default max delay of 120 seconds.
// Note that MaxDelay must resolve to value greater than or equal to the MinDelay.
MaxDelay time.Duration
// LogWaitAttempts is used to enable logging for waiter retry attempts
LogWaitAttempts bool
// Retryable is function that can be used to override the service defined
// waiter-behavior based on operation output, or returned error. This function is
// used by the waiter to decide if a state is retryable or a terminal state. By
// default service-modeled logic will populate this option. This option can thus be
// used to define a custom waiter state with fall-back to service-modeled waiter
// state mutators.The function returns an error in case of a failure state. In case
// of retry state, this function returns a bool value of true and nil error, while
// in case of success it returns a bool value of false and nil error.
Retryable func(context.Context, *DescribeEndpointInput, *DescribeEndpointOutput, error) (bool, error)
}
// EndpointDeletedWaiter defines the waiters for EndpointDeleted
type EndpointDeletedWaiter struct {
client DescribeEndpointAPIClient
options EndpointDeletedWaiterOptions
}
// NewEndpointDeletedWaiter constructs a EndpointDeletedWaiter.
func NewEndpointDeletedWaiter(client DescribeEndpointAPIClient, optFns ...func(*EndpointDeletedWaiterOptions)) *EndpointDeletedWaiter {
options := EndpointDeletedWaiterOptions{}
options.MinDelay = 30 * time.Second
options.MaxDelay = 120 * time.Second
options.Retryable = endpointDeletedStateRetryable
for _, fn := range optFns {
fn(&options)
}
return &EndpointDeletedWaiter{
client: client,
options: options,
}
}
// Wait calls the waiter function for EndpointDeleted waiter. The maxWaitDur is
// the maximum wait duration the waiter will wait. The maxWaitDur is required and
// must be greater than zero.
func (w *EndpointDeletedWaiter) Wait(ctx context.Context, params *DescribeEndpointInput, maxWaitDur time.Duration, optFns ...func(*EndpointDeletedWaiterOptions)) error {
_, err := w.WaitForOutput(ctx, params, maxWaitDur, optFns...)
return err
}
// WaitForOutput calls the waiter function for EndpointDeleted waiter and returns
// the output of the successful operation. The maxWaitDur is the maximum wait
// duration the waiter will wait. The maxWaitDur is required and must be greater
// than zero.
func (w *EndpointDeletedWaiter) WaitForOutput(ctx context.Context, params *DescribeEndpointInput, maxWaitDur time.Duration, optFns ...func(*EndpointDeletedWaiterOptions)) (*DescribeEndpointOutput, error) {
if maxWaitDur <= 0 {
return nil, fmt.Errorf("maximum wait time for waiter must be greater than zero")
}
options := w.options
for _, fn := range optFns {
fn(&options)
}
if options.MaxDelay <= 0 {
options.MaxDelay = 120 * time.Second
}
if options.MinDelay > options.MaxDelay {
return nil, fmt.Errorf("minimum waiter delay %v must be lesser than or equal to maximum waiter delay of %v.", options.MinDelay, options.MaxDelay)
}
ctx, cancelFn := context.WithTimeout(ctx, maxWaitDur)
defer cancelFn()
logger := smithywaiter.Logger{}
remainingTime := maxWaitDur
var attempt int64
for {
attempt++
apiOptions := options.APIOptions
start := time.Now()
if options.LogWaitAttempts {
logger.Attempt = attempt
apiOptions = append([]func(*middleware.Stack) error{}, options.APIOptions...)
apiOptions = append(apiOptions, logger.AddLogger)
}
out, err := w.client.DescribeEndpoint(ctx, params, func(o *Options) {
o.APIOptions = append(o.APIOptions, apiOptions...)
})
retryable, err := options.Retryable(ctx, params, out, err)
if err != nil {
return nil, err
}
if !retryable {
return out, nil
}
remainingTime -= time.Since(start)
if remainingTime < options.MinDelay || remainingTime <= 0 {
break
}
// compute exponential backoff between waiter retries
delay, err := smithywaiter.ComputeDelay(
attempt, options.MinDelay, options.MaxDelay, remainingTime,
)
if err != nil {
return nil, fmt.Errorf("error computing waiter delay, %w", err)
}
remainingTime -= delay
// sleep for the delay amount before invoking a request
if err := smithytime.SleepWithContext(ctx, delay); err != nil {
return nil, fmt.Errorf("request cancelled while waiting, %w", err)
}
}
return nil, fmt.Errorf("exceeded max wait time for EndpointDeleted waiter")
}
func endpointDeletedStateRetryable(ctx context.Context, input *DescribeEndpointInput, output *DescribeEndpointOutput, err error) (bool, error) {
if err != nil {
var apiErr smithy.APIError
ok := errors.As(err, &apiErr)
if !ok {
return false, fmt.Errorf("expected err to be of type smithy.APIError, got %w", err)
}
if "ValidationException" == apiErr.ErrorCode() {
return false, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("EndpointStatus", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "Failed"
value, ok := pathValue.(types.EndpointStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.EndpointStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, fmt.Errorf("waiter state transitioned to Failure")
}
}
return true, nil
}
// EndpointInServiceWaiterOptions are waiter options for EndpointInServiceWaiter
type EndpointInServiceWaiterOptions 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
// MinDelay is the minimum amount of time to delay between retries. If unset,
// EndpointInServiceWaiter will use default minimum delay of 30 seconds. Note that
// MinDelay must resolve to a value lesser than or equal to the MaxDelay.
MinDelay time.Duration
// MaxDelay is the maximum amount of time to delay between retries. If unset or
// set to zero, EndpointInServiceWaiter will use default max delay of 120 seconds.
// Note that MaxDelay must resolve to value greater than or equal to the MinDelay.
MaxDelay time.Duration
// LogWaitAttempts is used to enable logging for waiter retry attempts
LogWaitAttempts bool
// Retryable is function that can be used to override the service defined
// waiter-behavior based on operation output, or returned error. This function is
// used by the waiter to decide if a state is retryable or a terminal state. By
// default service-modeled logic will populate this option. This option can thus be
// used to define a custom waiter state with fall-back to service-modeled waiter
// state mutators.The function returns an error in case of a failure state. In case
// of retry state, this function returns a bool value of true and nil error, while
// in case of success it returns a bool value of false and nil error.
Retryable func(context.Context, *DescribeEndpointInput, *DescribeEndpointOutput, error) (bool, error)
}
// EndpointInServiceWaiter defines the waiters for EndpointInService
type EndpointInServiceWaiter struct {
client DescribeEndpointAPIClient
options EndpointInServiceWaiterOptions
}
// NewEndpointInServiceWaiter constructs a EndpointInServiceWaiter.
func NewEndpointInServiceWaiter(client DescribeEndpointAPIClient, optFns ...func(*EndpointInServiceWaiterOptions)) *EndpointInServiceWaiter {
options := EndpointInServiceWaiterOptions{}
options.MinDelay = 30 * time.Second
options.MaxDelay = 120 * time.Second
options.Retryable = endpointInServiceStateRetryable
for _, fn := range optFns {
fn(&options)
}
return &EndpointInServiceWaiter{
client: client,
options: options,
}
}
// Wait calls the waiter function for EndpointInService waiter. The maxWaitDur is
// the maximum wait duration the waiter will wait. The maxWaitDur is required and
// must be greater than zero.
func (w *EndpointInServiceWaiter) Wait(ctx context.Context, params *DescribeEndpointInput, maxWaitDur time.Duration, optFns ...func(*EndpointInServiceWaiterOptions)) error {
_, err := w.WaitForOutput(ctx, params, maxWaitDur, optFns...)
return err
}
// WaitForOutput calls the waiter function for EndpointInService waiter and
// returns the output of the successful operation. The maxWaitDur is the maximum
// wait duration the waiter will wait. The maxWaitDur is required and must be
// greater than zero.
func (w *EndpointInServiceWaiter) WaitForOutput(ctx context.Context, params *DescribeEndpointInput, maxWaitDur time.Duration, optFns ...func(*EndpointInServiceWaiterOptions)) (*DescribeEndpointOutput, error) {
if maxWaitDur <= 0 {
return nil, fmt.Errorf("maximum wait time for waiter must be greater than zero")
}
options := w.options
for _, fn := range optFns {
fn(&options)
}
if options.MaxDelay <= 0 {
options.MaxDelay = 120 * time.Second
}
if options.MinDelay > options.MaxDelay {
return nil, fmt.Errorf("minimum waiter delay %v must be lesser than or equal to maximum waiter delay of %v.", options.MinDelay, options.MaxDelay)
}
ctx, cancelFn := context.WithTimeout(ctx, maxWaitDur)
defer cancelFn()
logger := smithywaiter.Logger{}
remainingTime := maxWaitDur
var attempt int64
for {
attempt++
apiOptions := options.APIOptions
start := time.Now()
if options.LogWaitAttempts {
logger.Attempt = attempt
apiOptions = append([]func(*middleware.Stack) error{}, options.APIOptions...)
apiOptions = append(apiOptions, logger.AddLogger)
}
out, err := w.client.DescribeEndpoint(ctx, params, func(o *Options) {
o.APIOptions = append(o.APIOptions, apiOptions...)
})
retryable, err := options.Retryable(ctx, params, out, err)
if err != nil {
return nil, err
}
if !retryable {
return out, nil
}
remainingTime -= time.Since(start)
if remainingTime < options.MinDelay || remainingTime <= 0 {
break
}
// compute exponential backoff between waiter retries
delay, err := smithywaiter.ComputeDelay(
attempt, options.MinDelay, options.MaxDelay, remainingTime,
)
if err != nil {
return nil, fmt.Errorf("error computing waiter delay, %w", err)
}
remainingTime -= delay
// sleep for the delay amount before invoking a request
if err := smithytime.SleepWithContext(ctx, delay); err != nil {
return nil, fmt.Errorf("request cancelled while waiting, %w", err)
}
}
return nil, fmt.Errorf("exceeded max wait time for EndpointInService waiter")
}
func endpointInServiceStateRetryable(ctx context.Context, input *DescribeEndpointInput, output *DescribeEndpointOutput, err error) (bool, error) {
if err == nil {
pathValue, err := jmespath.Search("EndpointStatus", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "InService"
value, ok := pathValue.(types.EndpointStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.EndpointStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("EndpointStatus", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "Failed"
value, ok := pathValue.(types.EndpointStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.EndpointStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, fmt.Errorf("waiter state transitioned to Failure")
}
}
if err != nil {
var apiErr smithy.APIError
ok := errors.As(err, &apiErr)
if !ok {
return false, fmt.Errorf("expected err to be of type smithy.APIError, got %w", err)
}
if "ValidationException" == apiErr.ErrorCode() {
return false, fmt.Errorf("waiter state transitioned to Failure")
}
}
return true, nil
}
func newServiceMetadataMiddleware_opDescribeEndpoint(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DescribeEndpoint",
}
}
| 584 |
aws-sdk-go-v2 | aws | Go | // 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 the description of an endpoint configuration created using the
// CreateEndpointConfig API.
func (c *Client) DescribeEndpointConfig(ctx context.Context, params *DescribeEndpointConfigInput, optFns ...func(*Options)) (*DescribeEndpointConfigOutput, error) {
if params == nil {
params = &DescribeEndpointConfigInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeEndpointConfig", params, optFns, c.addOperationDescribeEndpointConfigMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeEndpointConfigOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeEndpointConfigInput struct {
// The name of the endpoint configuration.
//
// This member is required.
EndpointConfigName *string
noSmithyDocumentSerde
}
type DescribeEndpointConfigOutput struct {
// A timestamp that shows when the endpoint configuration was created.
//
// This member is required.
CreationTime *time.Time
// The Amazon Resource Name (ARN) of the endpoint configuration.
//
// This member is required.
EndpointConfigArn *string
// Name of the SageMaker endpoint configuration.
//
// This member is required.
EndpointConfigName *string
// An array of ProductionVariant objects, one for each model that you want to host
// at this endpoint.
//
// This member is required.
ProductionVariants []types.ProductionVariant
// Returns the description of an endpoint configuration created using the
// CreateEndpointConfig (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html)
// API.
AsyncInferenceConfig *types.AsyncInferenceConfig
// Configuration to control how SageMaker captures inference data.
DataCaptureConfig *types.DataCaptureConfig
// The configuration parameters for an explainer.
ExplainerConfig *types.ExplainerConfig
// Amazon Web Services KMS key ID Amazon SageMaker uses to encrypt data when
// storing it on the ML storage volume attached to the instance.
KmsKeyId *string
// An array of ProductionVariant objects, one for each model that you want to host
// at this endpoint in shadow mode with production traffic replicated from the
// model specified on ProductionVariants .
ShadowProductionVariants []types.ProductionVariant
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeEndpointConfigMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeEndpointConfig{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeEndpointConfig{}, 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 = addOpDescribeEndpointConfigValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeEndpointConfig(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeEndpointConfig(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DescribeEndpointConfig",
}
}
| 165 |
aws-sdk-go-v2 | aws | Go | // 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"
)
// Provides a list of an experiment's properties.
func (c *Client) DescribeExperiment(ctx context.Context, params *DescribeExperimentInput, optFns ...func(*Options)) (*DescribeExperimentOutput, error) {
if params == nil {
params = &DescribeExperimentInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeExperiment", params, optFns, c.addOperationDescribeExperimentMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeExperimentOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeExperimentInput struct {
// The name of the experiment to describe.
//
// This member is required.
ExperimentName *string
noSmithyDocumentSerde
}
type DescribeExperimentOutput struct {
// Who created the experiment.
CreatedBy *types.UserContext
// When the experiment was created.
CreationTime *time.Time
// The description of the experiment.
Description *string
// The name of the experiment as displayed. If DisplayName isn't specified,
// ExperimentName is displayed.
DisplayName *string
// The Amazon Resource Name (ARN) of the experiment.
ExperimentArn *string
// The name of the experiment.
ExperimentName *string
// Who last modified the experiment.
LastModifiedBy *types.UserContext
// When the experiment was last modified.
LastModifiedTime *time.Time
// The Amazon Resource Name (ARN) of the source and, optionally, the type.
Source *types.ExperimentSource
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeExperimentMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeExperiment{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeExperiment{}, 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 = addOpDescribeExperimentValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeExperiment(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeExperiment(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DescribeExperiment",
}
}
| 151 |
aws-sdk-go-v2 | aws | Go | // 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"
)
// Use this operation to describe a FeatureGroup . The response includes
// information on the creation time, FeatureGroup name, the unique identifier for
// each FeatureGroup , and more.
func (c *Client) DescribeFeatureGroup(ctx context.Context, params *DescribeFeatureGroupInput, optFns ...func(*Options)) (*DescribeFeatureGroupOutput, error) {
if params == nil {
params = &DescribeFeatureGroupInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeFeatureGroup", params, optFns, c.addOperationDescribeFeatureGroupMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeFeatureGroupOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeFeatureGroupInput struct {
// The name of the FeatureGroup you want described.
//
// This member is required.
FeatureGroupName *string
// A token to resume pagination of the list of Features ( FeatureDefinitions ).
// 2,500 Features are returned by default.
NextToken *string
noSmithyDocumentSerde
}
type DescribeFeatureGroupOutput struct {
// A timestamp indicating when SageMaker created the FeatureGroup .
//
// This member is required.
CreationTime *time.Time
// 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 have a corresponding EventTime .
//
// This member is required.
EventTimeFeatureName *string
// A list of the Features in the FeatureGroup . Each feature is defined by a
// FeatureName and FeatureType .
//
// This member is required.
FeatureDefinitions []types.FeatureDefinition
// The Amazon Resource Name (ARN) of the FeatureGroup .
//
// This member is required.
FeatureGroupArn *string
// he name of the FeatureGroup .
//
// This member is required.
FeatureGroupName *string
// A token to resume pagination of the list of Features ( FeatureDefinitions ).
//
// This member is required.
NextToken *string
// The name of the Feature used for RecordIdentifier , whose value uniquely
// identifies a record stored in the feature store.
//
// This member is required.
RecordIdentifierFeatureName *string
// A free form description of the feature group.
Description *string
// The reason that the FeatureGroup failed to be replicated in the OfflineStore .
// This is failure can occur because:
// - The FeatureGroup could not be created in the OfflineStore .
// - The FeatureGroup could not be deleted from the OfflineStore .
FailureReason *string
// The status of the feature group.
FeatureGroupStatus types.FeatureGroupStatus
// A timestamp indicating when the feature group was last updated.
LastModifiedTime *time.Time
// A value indicating whether the update made to the feature group was successful.
LastUpdateStatus *types.LastUpdateStatus
// The configuration of the offline store. It includes the following
// configurations:
// - Amazon S3 location of the offline store.
// - Configuration of the Glue data catalog.
// - Table format of the offline store.
// - Option to disable the automatic creation of a Glue table for the offline
// store.
// - Encryption configuration.
OfflineStoreConfig *types.OfflineStoreConfig
// The status of the OfflineStore . Notifies you if replicating data into the
// OfflineStore has failed. Returns either: Active or Blocked
OfflineStoreStatus *types.OfflineStoreStatus
// The configuration for the OnlineStore .
OnlineStoreConfig *types.OnlineStoreConfig
// The size of the OnlineStore in bytes.
OnlineStoreTotalSizeBytes *int64
// The Amazon Resource Name (ARN) of the IAM execution role used to persist data
// into the OfflineStore if an OfflineStoreConfig is provided.
RoleArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeFeatureGroupMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeFeatureGroup{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeFeatureGroup{}, 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 = addOpDescribeFeatureGroupValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeFeatureGroup(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeFeatureGroup(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DescribeFeatureGroup",
}
}
| 211 |
aws-sdk-go-v2 | aws | Go | // 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"
)
// Shows the metadata for a feature within a feature group.
func (c *Client) DescribeFeatureMetadata(ctx context.Context, params *DescribeFeatureMetadataInput, optFns ...func(*Options)) (*DescribeFeatureMetadataOutput, error) {
if params == nil {
params = &DescribeFeatureMetadataInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeFeatureMetadata", params, optFns, c.addOperationDescribeFeatureMetadataMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeFeatureMetadataOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeFeatureMetadataInput struct {
// The name of the feature group containing the feature.
//
// This member is required.
FeatureGroupName *string
// The name of the feature.
//
// This member is required.
FeatureName *string
noSmithyDocumentSerde
}
type DescribeFeatureMetadataOutput struct {
// A timestamp indicating when the feature was created.
//
// This member is required.
CreationTime *time.Time
// The Amazon Resource Number (ARN) of the feature group that contains the feature.
//
// This member is required.
FeatureGroupArn *string
// The name of the feature group that you've specified.
//
// This member is required.
FeatureGroupName *string
// The name of the feature that you've specified.
//
// This member is required.
FeatureName *string
// The data type of the feature.
//
// This member is required.
FeatureType types.FeatureType
// A timestamp indicating when the metadata for the feature group was modified.
// For example, if you add a parameter describing the feature, the timestamp
// changes to reflect the last time you
//
// This member is required.
LastModifiedTime *time.Time
// The description you added to describe the feature.
Description *string
// The key-value pairs that you added to describe the feature.
Parameters []types.FeatureParameter
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeFeatureMetadataMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeFeatureMetadata{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeFeatureMetadata{}, 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 = addOpDescribeFeatureMetadataValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeFeatureMetadata(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeFeatureMetadata(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DescribeFeatureMetadata",
}
}
| 166 |
aws-sdk-go-v2 | aws | Go | // 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 the specified flow definition.
func (c *Client) DescribeFlowDefinition(ctx context.Context, params *DescribeFlowDefinitionInput, optFns ...func(*Options)) (*DescribeFlowDefinitionOutput, error) {
if params == nil {
params = &DescribeFlowDefinitionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeFlowDefinition", params, optFns, c.addOperationDescribeFlowDefinitionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeFlowDefinitionOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeFlowDefinitionInput struct {
// The name of the flow definition.
//
// This member is required.
FlowDefinitionName *string
noSmithyDocumentSerde
}
type DescribeFlowDefinitionOutput struct {
// The timestamp when the flow definition was created.
//
// This member is required.
CreationTime *time.Time
// The Amazon Resource Name (ARN) of the flow defintion.
//
// This member is required.
FlowDefinitionArn *string
// The Amazon Resource Name (ARN) of the flow definition.
//
// This member is required.
FlowDefinitionName *string
// The status of the flow definition. Valid values are listed below.
//
// This member is required.
FlowDefinitionStatus types.FlowDefinitionStatus
// An object containing information about who works on the task, the workforce
// task price, and other task details.
//
// This member is required.
HumanLoopConfig *types.HumanLoopConfig
// An object containing information about the output file.
//
// This member is required.
OutputConfig *types.FlowDefinitionOutputConfig
// The Amazon Resource Name (ARN) of the Amazon Web Services Identity and Access
// Management (IAM) execution role for the flow definition.
//
// This member is required.
RoleArn *string
// The reason your flow definition failed.
FailureReason *string
// An object containing information about what triggers a human review workflow.
HumanLoopActivationConfig *types.HumanLoopActivationConfig
// Container for configuring the source of human task requests. Used to specify if
// Amazon Rekognition or Amazon Textract is used as an integration source.
HumanLoopRequestSource *types.HumanLoopRequestSource
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeFlowDefinitionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeFlowDefinition{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeFlowDefinition{}, 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 = addOpDescribeFlowDefinitionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeFlowDefinition(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeFlowDefinition(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DescribeFlowDefinition",
}
}
| 170 |
aws-sdk-go-v2 | aws | Go | // 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"
)
// Describe a hub. Hub APIs are only callable through SageMaker Studio.
func (c *Client) DescribeHub(ctx context.Context, params *DescribeHubInput, optFns ...func(*Options)) (*DescribeHubOutput, error) {
if params == nil {
params = &DescribeHubInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeHub", params, optFns, c.addOperationDescribeHubMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeHubOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeHubInput struct {
// The name of the hub to describe.
//
// This member is required.
HubName *string
noSmithyDocumentSerde
}
type DescribeHubOutput struct {
// The date and time that the hub was created.
//
// This member is required.
CreationTime *time.Time
// The Amazon Resource Name (ARN) of the hub.
//
// This member is required.
HubArn *string
// The name of the hub.
//
// This member is required.
HubName *string
// The status of the hub.
//
// This member is required.
HubStatus types.HubStatus
// The date and time that the hub was last modified.
//
// This member is required.
LastModifiedTime *time.Time
// The failure reason if importing hub content failed.
FailureReason *string
// A description of the hub.
HubDescription *string
// The display name of the hub.
HubDisplayName *string
// The searchable keywords for the hub.
HubSearchKeywords []string
// The Amazon S3 storage configuration for the hub.
S3StorageConfig *types.HubS3StorageConfig
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeHubMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeHub{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeHub{}, 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 = addOpDescribeHubValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeHub(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeHub(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DescribeHub",
}
}
| 163 |
aws-sdk-go-v2 | aws | Go | // 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"
)
// Describe the content of a hub. Hub APIs are only callable through SageMaker
// Studio.
func (c *Client) DescribeHubContent(ctx context.Context, params *DescribeHubContentInput, optFns ...func(*Options)) (*DescribeHubContentOutput, error) {
if params == nil {
params = &DescribeHubContentInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeHubContent", params, optFns, c.addOperationDescribeHubContentMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeHubContentOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeHubContentInput struct {
// The name of the content to describe.
//
// This member is required.
HubContentName *string
// The type of content in the hub.
//
// This member is required.
HubContentType types.HubContentType
// The name of the hub that contains the content to describe.
//
// This member is required.
HubName *string
// The version of the content to describe.
HubContentVersion *string
noSmithyDocumentSerde
}
type DescribeHubContentOutput struct {
// The date and time that hub content was created.
//
// This member is required.
CreationTime *time.Time
// The document schema version for the hub content.
//
// This member is required.
DocumentSchemaVersion *string
// The Amazon Resource Name (ARN) of the hub that contains the content.
//
// This member is required.
HubArn *string
// The Amazon Resource Name (ARN) of the hub content.
//
// This member is required.
HubContentArn *string
// The hub content document that describes information about the hub content such
// as type, associated containers, scripts, and more.
//
// This member is required.
HubContentDocument *string
// The name of the hub content.
//
// This member is required.
HubContentName *string
// The status of the hub content.
//
// This member is required.
HubContentStatus types.HubContentStatus
// The type of hub content.
//
// This member is required.
HubContentType types.HubContentType
// The version of the hub content.
//
// This member is required.
HubContentVersion *string
// The name of the hub that contains the content.
//
// This member is required.
HubName *string
// The failure reason if importing hub content failed.
FailureReason *string
// The location of any dependencies that the hub content has, such as scripts,
// model artifacts, datasets, or notebooks.
HubContentDependencies []types.HubContentDependency
// A description of the hub content.
HubContentDescription *string
// The display name of the hub content.
HubContentDisplayName *string
// A string that provides a description of the hub content. This string can
// include links, tables, and standard markdown formating.
HubContentMarkdown *string
// The searchable keywords for the hub content.
HubContentSearchKeywords []string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeHubContentMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeHubContent{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeHubContent{}, 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 = addOpDescribeHubContentValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeHubContent(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeHubContent(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DescribeHubContent",
}
}
| 208 |
aws-sdk-go-v2 | aws | Go | // 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 the requested human task user interface (worker task
// template).
func (c *Client) DescribeHumanTaskUi(ctx context.Context, params *DescribeHumanTaskUiInput, optFns ...func(*Options)) (*DescribeHumanTaskUiOutput, error) {
if params == nil {
params = &DescribeHumanTaskUiInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeHumanTaskUi", params, optFns, c.addOperationDescribeHumanTaskUiMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeHumanTaskUiOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeHumanTaskUiInput struct {
// The name of the human task user interface (worker task template) you want
// information about.
//
// This member is required.
HumanTaskUiName *string
noSmithyDocumentSerde
}
type DescribeHumanTaskUiOutput struct {
// The timestamp when the human task user interface was created.
//
// This member is required.
CreationTime *time.Time
// The Amazon Resource Name (ARN) of the human task user interface (worker task
// template).
//
// This member is required.
HumanTaskUiArn *string
// The name of the human task user interface (worker task template).
//
// This member is required.
HumanTaskUiName *string
// Container for user interface template information.
//
// This member is required.
UiTemplate *types.UiTemplateInfo
// The status of the human task user interface (worker task template). Valid
// values are listed below.
HumanTaskUiStatus types.HumanTaskUiStatus
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeHumanTaskUiMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeHumanTaskUi{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeHumanTaskUi{}, 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 = addOpDescribeHumanTaskUiValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeHumanTaskUi(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeHumanTaskUi(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DescribeHumanTaskUi",
}
}
| 150 |
aws-sdk-go-v2 | aws | Go | // 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 a hyperparameter tuning job, depending on the fields
// selected. These fields can include the name, Amazon Resource Name (ARN), job
// status of your tuning job and more.
func (c *Client) DescribeHyperParameterTuningJob(ctx context.Context, params *DescribeHyperParameterTuningJobInput, optFns ...func(*Options)) (*DescribeHyperParameterTuningJobOutput, error) {
if params == nil {
params = &DescribeHyperParameterTuningJobInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeHyperParameterTuningJob", params, optFns, c.addOperationDescribeHyperParameterTuningJobMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeHyperParameterTuningJobOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeHyperParameterTuningJobInput struct {
// The name of the tuning job.
//
// This member is required.
HyperParameterTuningJobName *string
noSmithyDocumentSerde
}
type DescribeHyperParameterTuningJobOutput struct {
// The date and time that the tuning job started.
//
// This member is required.
CreationTime *time.Time
// The Amazon Resource Name (ARN) of the tuning job.
//
// This member is required.
HyperParameterTuningJobArn *string
// The HyperParameterTuningJobConfig (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_HyperParameterTuningJobConfig.html)
// object that specifies the configuration of the tuning job.
//
// This member is required.
HyperParameterTuningJobConfig *types.HyperParameterTuningJobConfig
// The name of the hyperparameter tuning job.
//
// This member is required.
HyperParameterTuningJobName *string
// The status of the tuning job: InProgress, Completed, Failed, Stopping, or
// Stopped.
//
// This member is required.
HyperParameterTuningJobStatus types.HyperParameterTuningJobStatus
// The ObjectiveStatusCounters (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ObjectiveStatusCounters.html)
// object that specifies the number of training jobs, categorized by the status of
// their final objective metric, that this tuning job launched.
//
// This member is required.
ObjectiveStatusCounters *types.ObjectiveStatusCounters
// The TrainingJobStatusCounters (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TrainingJobStatusCounters.html)
// object that specifies the number of training jobs, categorized by status, that
// this tuning job launched.
//
// This member is required.
TrainingJobStatusCounters *types.TrainingJobStatusCounters
// A flag to indicate if autotune is enabled for the hyperparameter tuning job.
Autotune *types.Autotune
// A TrainingJobSummary (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TrainingJobSummary.html)
// object that describes the training job that completed with the best current
// HyperParameterTuningJobObjective (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_HyperParameterTuningJobObjective.html)
// .
BestTrainingJob *types.HyperParameterTrainingJobSummary
// The total resources consumed by your hyperparameter tuning job.
ConsumedResources *types.HyperParameterTuningJobConsumedResources
// If the tuning job failed, the reason it failed.
FailureReason *string
// The date and time that the tuning job ended.
HyperParameterTuningEndTime *time.Time
// The date and time that the status of the tuning job was modified.
LastModifiedTime *time.Time
// If the hyperparameter tuning job is an warm start tuning job with a
// WarmStartType of IDENTICAL_DATA_AND_ALGORITHM , this is the TrainingJobSummary (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TrainingJobSummary.html)
// for the training job with the best objective metric value of all training jobs
// launched by this tuning job and all parent jobs specified for the warm start
// tuning job.
OverallBestTrainingJob *types.HyperParameterTrainingJobSummary
// The HyperParameterTrainingJobDefinition (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_HyperParameterTrainingJobDefinition.html)
// object that specifies the definition of the training jobs that this tuning job
// launches.
TrainingJobDefinition *types.HyperParameterTrainingJobDefinition
// A list of the HyperParameterTrainingJobDefinition (https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_HyperParameterTrainingJobDefinition.html)
// objects launched for this tuning job.
TrainingJobDefinitions []types.HyperParameterTrainingJobDefinition
// Tuning job completion information returned as the response from a
// hyperparameter tuning job. This information tells if your tuning job has or has
// not converged. It also includes the number of training jobs that have not
// improved model performance as evaluated against the objective function.
TuningJobCompletionDetails *types.HyperParameterTuningJobCompletionDetails
// The configuration for starting the hyperparameter parameter 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.
WarmStartConfig *types.HyperParameterTuningJobWarmStartConfig
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeHyperParameterTuningJobMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeHyperParameterTuningJob{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeHyperParameterTuningJob{}, 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 = addOpDescribeHyperParameterTuningJobValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeHyperParameterTuningJob(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
func newServiceMetadataMiddleware_opDescribeHyperParameterTuningJob(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DescribeHyperParameterTuningJob",
}
}
| 215 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
"errors"
"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"
smithy "github.com/aws/smithy-go"
"github.com/aws/smithy-go/middleware"
smithytime "github.com/aws/smithy-go/time"
smithyhttp "github.com/aws/smithy-go/transport/http"
smithywaiter "github.com/aws/smithy-go/waiter"
"github.com/jmespath/go-jmespath"
"time"
)
// Describes a SageMaker image.
func (c *Client) DescribeImage(ctx context.Context, params *DescribeImageInput, optFns ...func(*Options)) (*DescribeImageOutput, error) {
if params == nil {
params = &DescribeImageInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeImage", params, optFns, c.addOperationDescribeImageMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeImageOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeImageInput struct {
// The name of the image to describe.
//
// This member is required.
ImageName *string
noSmithyDocumentSerde
}
type DescribeImageOutput struct {
// When the image was created.
CreationTime *time.Time
// The description of the image.
Description *string
// The name of the image as displayed.
DisplayName *string
// When a create, update, or delete operation fails, the reason for the failure.
FailureReason *string
// The ARN of the image.
ImageArn *string
// The name of the image.
ImageName *string
// The status of the image.
ImageStatus types.ImageStatus
// When the image was last modified.
LastModifiedTime *time.Time
// The ARN of the IAM role that enables Amazon SageMaker to perform tasks on your
// behalf.
RoleArn *string
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeImageMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeImage{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeImage{}, 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 = addOpDescribeImageValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeImage(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// DescribeImageAPIClient is a client that implements the DescribeImage operation.
type DescribeImageAPIClient interface {
DescribeImage(context.Context, *DescribeImageInput, ...func(*Options)) (*DescribeImageOutput, error)
}
var _ DescribeImageAPIClient = (*Client)(nil)
// ImageCreatedWaiterOptions are waiter options for ImageCreatedWaiter
type ImageCreatedWaiterOptions 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
// MinDelay is the minimum amount of time to delay between retries. If unset,
// ImageCreatedWaiter will use default minimum delay of 60 seconds. Note that
// MinDelay must resolve to a value lesser than or equal to the MaxDelay.
MinDelay time.Duration
// MaxDelay is the maximum amount of time to delay between retries. If unset or
// set to zero, ImageCreatedWaiter will use default max delay of 120 seconds. Note
// that MaxDelay must resolve to value greater than or equal to the MinDelay.
MaxDelay time.Duration
// LogWaitAttempts is used to enable logging for waiter retry attempts
LogWaitAttempts bool
// Retryable is function that can be used to override the service defined
// waiter-behavior based on operation output, or returned error. This function is
// used by the waiter to decide if a state is retryable or a terminal state. By
// default service-modeled logic will populate this option. This option can thus be
// used to define a custom waiter state with fall-back to service-modeled waiter
// state mutators.The function returns an error in case of a failure state. In case
// of retry state, this function returns a bool value of true and nil error, while
// in case of success it returns a bool value of false and nil error.
Retryable func(context.Context, *DescribeImageInput, *DescribeImageOutput, error) (bool, error)
}
// ImageCreatedWaiter defines the waiters for ImageCreated
type ImageCreatedWaiter struct {
client DescribeImageAPIClient
options ImageCreatedWaiterOptions
}
// NewImageCreatedWaiter constructs a ImageCreatedWaiter.
func NewImageCreatedWaiter(client DescribeImageAPIClient, optFns ...func(*ImageCreatedWaiterOptions)) *ImageCreatedWaiter {
options := ImageCreatedWaiterOptions{}
options.MinDelay = 60 * time.Second
options.MaxDelay = 120 * time.Second
options.Retryable = imageCreatedStateRetryable
for _, fn := range optFns {
fn(&options)
}
return &ImageCreatedWaiter{
client: client,
options: options,
}
}
// Wait calls the waiter function for ImageCreated waiter. The maxWaitDur is the
// maximum wait duration the waiter will wait. The maxWaitDur is required and must
// be greater than zero.
func (w *ImageCreatedWaiter) Wait(ctx context.Context, params *DescribeImageInput, maxWaitDur time.Duration, optFns ...func(*ImageCreatedWaiterOptions)) error {
_, err := w.WaitForOutput(ctx, params, maxWaitDur, optFns...)
return err
}
// WaitForOutput calls the waiter function for ImageCreated waiter and returns the
// output of the successful operation. The maxWaitDur is the maximum wait duration
// the waiter will wait. The maxWaitDur is required and must be greater than zero.
func (w *ImageCreatedWaiter) WaitForOutput(ctx context.Context, params *DescribeImageInput, maxWaitDur time.Duration, optFns ...func(*ImageCreatedWaiterOptions)) (*DescribeImageOutput, error) {
if maxWaitDur <= 0 {
return nil, fmt.Errorf("maximum wait time for waiter must be greater than zero")
}
options := w.options
for _, fn := range optFns {
fn(&options)
}
if options.MaxDelay <= 0 {
options.MaxDelay = 120 * time.Second
}
if options.MinDelay > options.MaxDelay {
return nil, fmt.Errorf("minimum waiter delay %v must be lesser than or equal to maximum waiter delay of %v.", options.MinDelay, options.MaxDelay)
}
ctx, cancelFn := context.WithTimeout(ctx, maxWaitDur)
defer cancelFn()
logger := smithywaiter.Logger{}
remainingTime := maxWaitDur
var attempt int64
for {
attempt++
apiOptions := options.APIOptions
start := time.Now()
if options.LogWaitAttempts {
logger.Attempt = attempt
apiOptions = append([]func(*middleware.Stack) error{}, options.APIOptions...)
apiOptions = append(apiOptions, logger.AddLogger)
}
out, err := w.client.DescribeImage(ctx, params, func(o *Options) {
o.APIOptions = append(o.APIOptions, apiOptions...)
})
retryable, err := options.Retryable(ctx, params, out, err)
if err != nil {
return nil, err
}
if !retryable {
return out, nil
}
remainingTime -= time.Since(start)
if remainingTime < options.MinDelay || remainingTime <= 0 {
break
}
// compute exponential backoff between waiter retries
delay, err := smithywaiter.ComputeDelay(
attempt, options.MinDelay, options.MaxDelay, remainingTime,
)
if err != nil {
return nil, fmt.Errorf("error computing waiter delay, %w", err)
}
remainingTime -= delay
// sleep for the delay amount before invoking a request
if err := smithytime.SleepWithContext(ctx, delay); err != nil {
return nil, fmt.Errorf("request cancelled while waiting, %w", err)
}
}
return nil, fmt.Errorf("exceeded max wait time for ImageCreated waiter")
}
func imageCreatedStateRetryable(ctx context.Context, input *DescribeImageInput, output *DescribeImageOutput, err error) (bool, error) {
if err == nil {
pathValue, err := jmespath.Search("ImageStatus", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "CREATED"
value, ok := pathValue.(types.ImageStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.ImageStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("ImageStatus", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "CREATE_FAILED"
value, ok := pathValue.(types.ImageStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.ImageStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, fmt.Errorf("waiter state transitioned to Failure")
}
}
if err != nil {
var apiErr smithy.APIError
ok := errors.As(err, &apiErr)
if !ok {
return false, fmt.Errorf("expected err to be of type smithy.APIError, got %w", err)
}
if "ValidationException" == apiErr.ErrorCode() {
return false, fmt.Errorf("waiter state transitioned to Failure")
}
}
return true, nil
}
// ImageDeletedWaiterOptions are waiter options for ImageDeletedWaiter
type ImageDeletedWaiterOptions 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
// MinDelay is the minimum amount of time to delay between retries. If unset,
// ImageDeletedWaiter will use default minimum delay of 60 seconds. Note that
// MinDelay must resolve to a value lesser than or equal to the MaxDelay.
MinDelay time.Duration
// MaxDelay is the maximum amount of time to delay between retries. If unset or
// set to zero, ImageDeletedWaiter will use default max delay of 120 seconds. Note
// that MaxDelay must resolve to value greater than or equal to the MinDelay.
MaxDelay time.Duration
// LogWaitAttempts is used to enable logging for waiter retry attempts
LogWaitAttempts bool
// Retryable is function that can be used to override the service defined
// waiter-behavior based on operation output, or returned error. This function is
// used by the waiter to decide if a state is retryable or a terminal state. By
// default service-modeled logic will populate this option. This option can thus be
// used to define a custom waiter state with fall-back to service-modeled waiter
// state mutators.The function returns an error in case of a failure state. In case
// of retry state, this function returns a bool value of true and nil error, while
// in case of success it returns a bool value of false and nil error.
Retryable func(context.Context, *DescribeImageInput, *DescribeImageOutput, error) (bool, error)
}
// ImageDeletedWaiter defines the waiters for ImageDeleted
type ImageDeletedWaiter struct {
client DescribeImageAPIClient
options ImageDeletedWaiterOptions
}
// NewImageDeletedWaiter constructs a ImageDeletedWaiter.
func NewImageDeletedWaiter(client DescribeImageAPIClient, optFns ...func(*ImageDeletedWaiterOptions)) *ImageDeletedWaiter {
options := ImageDeletedWaiterOptions{}
options.MinDelay = 60 * time.Second
options.MaxDelay = 120 * time.Second
options.Retryable = imageDeletedStateRetryable
for _, fn := range optFns {
fn(&options)
}
return &ImageDeletedWaiter{
client: client,
options: options,
}
}
// Wait calls the waiter function for ImageDeleted waiter. The maxWaitDur is the
// maximum wait duration the waiter will wait. The maxWaitDur is required and must
// be greater than zero.
func (w *ImageDeletedWaiter) Wait(ctx context.Context, params *DescribeImageInput, maxWaitDur time.Duration, optFns ...func(*ImageDeletedWaiterOptions)) error {
_, err := w.WaitForOutput(ctx, params, maxWaitDur, optFns...)
return err
}
// WaitForOutput calls the waiter function for ImageDeleted waiter and returns the
// output of the successful operation. The maxWaitDur is the maximum wait duration
// the waiter will wait. The maxWaitDur is required and must be greater than zero.
func (w *ImageDeletedWaiter) WaitForOutput(ctx context.Context, params *DescribeImageInput, maxWaitDur time.Duration, optFns ...func(*ImageDeletedWaiterOptions)) (*DescribeImageOutput, error) {
if maxWaitDur <= 0 {
return nil, fmt.Errorf("maximum wait time for waiter must be greater than zero")
}
options := w.options
for _, fn := range optFns {
fn(&options)
}
if options.MaxDelay <= 0 {
options.MaxDelay = 120 * time.Second
}
if options.MinDelay > options.MaxDelay {
return nil, fmt.Errorf("minimum waiter delay %v must be lesser than or equal to maximum waiter delay of %v.", options.MinDelay, options.MaxDelay)
}
ctx, cancelFn := context.WithTimeout(ctx, maxWaitDur)
defer cancelFn()
logger := smithywaiter.Logger{}
remainingTime := maxWaitDur
var attempt int64
for {
attempt++
apiOptions := options.APIOptions
start := time.Now()
if options.LogWaitAttempts {
logger.Attempt = attempt
apiOptions = append([]func(*middleware.Stack) error{}, options.APIOptions...)
apiOptions = append(apiOptions, logger.AddLogger)
}
out, err := w.client.DescribeImage(ctx, params, func(o *Options) {
o.APIOptions = append(o.APIOptions, apiOptions...)
})
retryable, err := options.Retryable(ctx, params, out, err)
if err != nil {
return nil, err
}
if !retryable {
return out, nil
}
remainingTime -= time.Since(start)
if remainingTime < options.MinDelay || remainingTime <= 0 {
break
}
// compute exponential backoff between waiter retries
delay, err := smithywaiter.ComputeDelay(
attempt, options.MinDelay, options.MaxDelay, remainingTime,
)
if err != nil {
return nil, fmt.Errorf("error computing waiter delay, %w", err)
}
remainingTime -= delay
// sleep for the delay amount before invoking a request
if err := smithytime.SleepWithContext(ctx, delay); err != nil {
return nil, fmt.Errorf("request cancelled while waiting, %w", err)
}
}
return nil, fmt.Errorf("exceeded max wait time for ImageDeleted waiter")
}
func imageDeletedStateRetryable(ctx context.Context, input *DescribeImageInput, output *DescribeImageOutput, err error) (bool, error) {
if err != nil {
var apiErr smithy.APIError
ok := errors.As(err, &apiErr)
if !ok {
return false, fmt.Errorf("expected err to be of type smithy.APIError, got %w", err)
}
if "ResourceNotFoundException" == apiErr.ErrorCode() {
return false, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("ImageStatus", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "DELETE_FAILED"
value, ok := pathValue.(types.ImageStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.ImageStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, fmt.Errorf("waiter state transitioned to Failure")
}
}
if err != nil {
var apiErr smithy.APIError
ok := errors.As(err, &apiErr)
if !ok {
return false, fmt.Errorf("expected err to be of type smithy.APIError, got %w", err)
}
if "ValidationException" == apiErr.ErrorCode() {
return false, fmt.Errorf("waiter state transitioned to Failure")
}
}
return true, nil
}
// ImageUpdatedWaiterOptions are waiter options for ImageUpdatedWaiter
type ImageUpdatedWaiterOptions 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
// MinDelay is the minimum amount of time to delay between retries. If unset,
// ImageUpdatedWaiter will use default minimum delay of 60 seconds. Note that
// MinDelay must resolve to a value lesser than or equal to the MaxDelay.
MinDelay time.Duration
// MaxDelay is the maximum amount of time to delay between retries. If unset or
// set to zero, ImageUpdatedWaiter will use default max delay of 120 seconds. Note
// that MaxDelay must resolve to value greater than or equal to the MinDelay.
MaxDelay time.Duration
// LogWaitAttempts is used to enable logging for waiter retry attempts
LogWaitAttempts bool
// Retryable is function that can be used to override the service defined
// waiter-behavior based on operation output, or returned error. This function is
// used by the waiter to decide if a state is retryable or a terminal state. By
// default service-modeled logic will populate this option. This option can thus be
// used to define a custom waiter state with fall-back to service-modeled waiter
// state mutators.The function returns an error in case of a failure state. In case
// of retry state, this function returns a bool value of true and nil error, while
// in case of success it returns a bool value of false and nil error.
Retryable func(context.Context, *DescribeImageInput, *DescribeImageOutput, error) (bool, error)
}
// ImageUpdatedWaiter defines the waiters for ImageUpdated
type ImageUpdatedWaiter struct {
client DescribeImageAPIClient
options ImageUpdatedWaiterOptions
}
// NewImageUpdatedWaiter constructs a ImageUpdatedWaiter.
func NewImageUpdatedWaiter(client DescribeImageAPIClient, optFns ...func(*ImageUpdatedWaiterOptions)) *ImageUpdatedWaiter {
options := ImageUpdatedWaiterOptions{}
options.MinDelay = 60 * time.Second
options.MaxDelay = 120 * time.Second
options.Retryable = imageUpdatedStateRetryable
for _, fn := range optFns {
fn(&options)
}
return &ImageUpdatedWaiter{
client: client,
options: options,
}
}
// Wait calls the waiter function for ImageUpdated waiter. The maxWaitDur is the
// maximum wait duration the waiter will wait. The maxWaitDur is required and must
// be greater than zero.
func (w *ImageUpdatedWaiter) Wait(ctx context.Context, params *DescribeImageInput, maxWaitDur time.Duration, optFns ...func(*ImageUpdatedWaiterOptions)) error {
_, err := w.WaitForOutput(ctx, params, maxWaitDur, optFns...)
return err
}
// WaitForOutput calls the waiter function for ImageUpdated waiter and returns the
// output of the successful operation. The maxWaitDur is the maximum wait duration
// the waiter will wait. The maxWaitDur is required and must be greater than zero.
func (w *ImageUpdatedWaiter) WaitForOutput(ctx context.Context, params *DescribeImageInput, maxWaitDur time.Duration, optFns ...func(*ImageUpdatedWaiterOptions)) (*DescribeImageOutput, error) {
if maxWaitDur <= 0 {
return nil, fmt.Errorf("maximum wait time for waiter must be greater than zero")
}
options := w.options
for _, fn := range optFns {
fn(&options)
}
if options.MaxDelay <= 0 {
options.MaxDelay = 120 * time.Second
}
if options.MinDelay > options.MaxDelay {
return nil, fmt.Errorf("minimum waiter delay %v must be lesser than or equal to maximum waiter delay of %v.", options.MinDelay, options.MaxDelay)
}
ctx, cancelFn := context.WithTimeout(ctx, maxWaitDur)
defer cancelFn()
logger := smithywaiter.Logger{}
remainingTime := maxWaitDur
var attempt int64
for {
attempt++
apiOptions := options.APIOptions
start := time.Now()
if options.LogWaitAttempts {
logger.Attempt = attempt
apiOptions = append([]func(*middleware.Stack) error{}, options.APIOptions...)
apiOptions = append(apiOptions, logger.AddLogger)
}
out, err := w.client.DescribeImage(ctx, params, func(o *Options) {
o.APIOptions = append(o.APIOptions, apiOptions...)
})
retryable, err := options.Retryable(ctx, params, out, err)
if err != nil {
return nil, err
}
if !retryable {
return out, nil
}
remainingTime -= time.Since(start)
if remainingTime < options.MinDelay || remainingTime <= 0 {
break
}
// compute exponential backoff between waiter retries
delay, err := smithywaiter.ComputeDelay(
attempt, options.MinDelay, options.MaxDelay, remainingTime,
)
if err != nil {
return nil, fmt.Errorf("error computing waiter delay, %w", err)
}
remainingTime -= delay
// sleep for the delay amount before invoking a request
if err := smithytime.SleepWithContext(ctx, delay); err != nil {
return nil, fmt.Errorf("request cancelled while waiting, %w", err)
}
}
return nil, fmt.Errorf("exceeded max wait time for ImageUpdated waiter")
}
func imageUpdatedStateRetryable(ctx context.Context, input *DescribeImageInput, output *DescribeImageOutput, err error) (bool, error) {
if err == nil {
pathValue, err := jmespath.Search("ImageStatus", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "CREATED"
value, ok := pathValue.(types.ImageStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.ImageStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("ImageStatus", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "UPDATE_FAILED"
value, ok := pathValue.(types.ImageStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.ImageStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, fmt.Errorf("waiter state transitioned to Failure")
}
}
if err != nil {
var apiErr smithy.APIError
ok := errors.As(err, &apiErr)
if !ok {
return false, fmt.Errorf("expected err to be of type smithy.APIError, got %w", err)
}
if "ValidationException" == apiErr.ErrorCode() {
return false, fmt.Errorf("waiter state transitioned to Failure")
}
}
return true, nil
}
func newServiceMetadataMiddleware_opDescribeImage(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DescribeImage",
}
}
| 723 |
aws-sdk-go-v2 | aws | Go | // Code generated by smithy-go-codegen DO NOT EDIT.
package sagemaker
import (
"context"
"errors"
"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"
smithy "github.com/aws/smithy-go"
"github.com/aws/smithy-go/middleware"
smithytime "github.com/aws/smithy-go/time"
smithyhttp "github.com/aws/smithy-go/transport/http"
smithywaiter "github.com/aws/smithy-go/waiter"
"github.com/jmespath/go-jmespath"
"time"
)
// Describes a version of a SageMaker image.
func (c *Client) DescribeImageVersion(ctx context.Context, params *DescribeImageVersionInput, optFns ...func(*Options)) (*DescribeImageVersionOutput, error) {
if params == nil {
params = &DescribeImageVersionInput{}
}
result, metadata, err := c.invokeOperation(ctx, "DescribeImageVersion", params, optFns, c.addOperationDescribeImageVersionMiddlewares)
if err != nil {
return nil, err
}
out := result.(*DescribeImageVersionOutput)
out.ResultMetadata = metadata
return out, nil
}
type DescribeImageVersionInput struct {
// The name of the image.
//
// This member is required.
ImageName *string
// The alias of the image version.
Alias *string
// The version of the image. If not specified, the latest version is described.
Version *int32
noSmithyDocumentSerde
}
type DescribeImageVersionOutput struct {
// The registry path of the container image on which this image version is based.
BaseImage *string
// The registry path of the container image that contains this image version.
ContainerImage *string
// When the version was created.
CreationTime *time.Time
// When a create or delete operation fails, the reason for the failure.
FailureReason *string
// Indicates Horovod compatibility.
Horovod bool
// The ARN of the image the version is based on.
ImageArn *string
// The ARN of the version.
ImageVersionArn *string
// The status of the version.
ImageVersionStatus types.ImageVersionStatus
// Indicates SageMaker job type compatibility.
// - TRAINING : The image version is compatible with SageMaker training jobs.
// - INFERENCE : The image version is compatible with SageMaker inference jobs.
// - NOTEBOOK_KERNEL : The image version is compatible with SageMaker notebook
// kernels.
JobType types.JobType
// When the version was last modified.
LastModifiedTime *time.Time
// The machine learning framework vended in the image version.
MLFramework *string
// Indicates CPU or GPU compatibility.
// - CPU : The image version is compatible with CPU.
// - GPU : The image version is compatible with GPU.
Processor types.Processor
// The supported programming language and its version.
ProgrammingLang *string
// The maintainer description of the image version.
ReleaseNotes *string
// The stability of the image version specified by the maintainer.
// - NOT_PROVIDED : The maintainers did not provide a status for image version
// stability.
// - STABLE : The image version is stable.
// - TO_BE_ARCHIVED : The image version is set to be archived. Custom image
// versions that are set to be archived are automatically archived after three
// months.
// - ARCHIVED : The image version is archived. Archived image versions are not
// searchable and are no longer actively supported.
VendorGuidance types.VendorGuidance
// The version number.
Version *int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationDescribeImageVersionMiddlewares(stack *middleware.Stack, options Options) (err error) {
err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeImageVersion{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeImageVersion{}, 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 = addOpDescribeImageVersionValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeImageVersion(options.Region), middleware.Before); err != nil {
return err
}
if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
return nil
}
// DescribeImageVersionAPIClient is a client that implements the
// DescribeImageVersion operation.
type DescribeImageVersionAPIClient interface {
DescribeImageVersion(context.Context, *DescribeImageVersionInput, ...func(*Options)) (*DescribeImageVersionOutput, error)
}
var _ DescribeImageVersionAPIClient = (*Client)(nil)
// ImageVersionCreatedWaiterOptions are waiter options for
// ImageVersionCreatedWaiter
type ImageVersionCreatedWaiterOptions 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
// MinDelay is the minimum amount of time to delay between retries. If unset,
// ImageVersionCreatedWaiter will use default minimum delay of 60 seconds. Note
// that MinDelay must resolve to a value lesser than or equal to the MaxDelay.
MinDelay time.Duration
// MaxDelay is the maximum amount of time to delay between retries. If unset or
// set to zero, ImageVersionCreatedWaiter will use default max delay of 120
// seconds. Note that MaxDelay must resolve to value greater than or equal to the
// MinDelay.
MaxDelay time.Duration
// LogWaitAttempts is used to enable logging for waiter retry attempts
LogWaitAttempts bool
// Retryable is function that can be used to override the service defined
// waiter-behavior based on operation output, or returned error. This function is
// used by the waiter to decide if a state is retryable or a terminal state. By
// default service-modeled logic will populate this option. This option can thus be
// used to define a custom waiter state with fall-back to service-modeled waiter
// state mutators.The function returns an error in case of a failure state. In case
// of retry state, this function returns a bool value of true and nil error, while
// in case of success it returns a bool value of false and nil error.
Retryable func(context.Context, *DescribeImageVersionInput, *DescribeImageVersionOutput, error) (bool, error)
}
// ImageVersionCreatedWaiter defines the waiters for ImageVersionCreated
type ImageVersionCreatedWaiter struct {
client DescribeImageVersionAPIClient
options ImageVersionCreatedWaiterOptions
}
// NewImageVersionCreatedWaiter constructs a ImageVersionCreatedWaiter.
func NewImageVersionCreatedWaiter(client DescribeImageVersionAPIClient, optFns ...func(*ImageVersionCreatedWaiterOptions)) *ImageVersionCreatedWaiter {
options := ImageVersionCreatedWaiterOptions{}
options.MinDelay = 60 * time.Second
options.MaxDelay = 120 * time.Second
options.Retryable = imageVersionCreatedStateRetryable
for _, fn := range optFns {
fn(&options)
}
return &ImageVersionCreatedWaiter{
client: client,
options: options,
}
}
// Wait calls the waiter function for ImageVersionCreated waiter. The maxWaitDur
// is the maximum wait duration the waiter will wait. The maxWaitDur is required
// and must be greater than zero.
func (w *ImageVersionCreatedWaiter) Wait(ctx context.Context, params *DescribeImageVersionInput, maxWaitDur time.Duration, optFns ...func(*ImageVersionCreatedWaiterOptions)) error {
_, err := w.WaitForOutput(ctx, params, maxWaitDur, optFns...)
return err
}
// WaitForOutput calls the waiter function for ImageVersionCreated waiter and
// returns the output of the successful operation. The maxWaitDur is the maximum
// wait duration the waiter will wait. The maxWaitDur is required and must be
// greater than zero.
func (w *ImageVersionCreatedWaiter) WaitForOutput(ctx context.Context, params *DescribeImageVersionInput, maxWaitDur time.Duration, optFns ...func(*ImageVersionCreatedWaiterOptions)) (*DescribeImageVersionOutput, error) {
if maxWaitDur <= 0 {
return nil, fmt.Errorf("maximum wait time for waiter must be greater than zero")
}
options := w.options
for _, fn := range optFns {
fn(&options)
}
if options.MaxDelay <= 0 {
options.MaxDelay = 120 * time.Second
}
if options.MinDelay > options.MaxDelay {
return nil, fmt.Errorf("minimum waiter delay %v must be lesser than or equal to maximum waiter delay of %v.", options.MinDelay, options.MaxDelay)
}
ctx, cancelFn := context.WithTimeout(ctx, maxWaitDur)
defer cancelFn()
logger := smithywaiter.Logger{}
remainingTime := maxWaitDur
var attempt int64
for {
attempt++
apiOptions := options.APIOptions
start := time.Now()
if options.LogWaitAttempts {
logger.Attempt = attempt
apiOptions = append([]func(*middleware.Stack) error{}, options.APIOptions...)
apiOptions = append(apiOptions, logger.AddLogger)
}
out, err := w.client.DescribeImageVersion(ctx, params, func(o *Options) {
o.APIOptions = append(o.APIOptions, apiOptions...)
})
retryable, err := options.Retryable(ctx, params, out, err)
if err != nil {
return nil, err
}
if !retryable {
return out, nil
}
remainingTime -= time.Since(start)
if remainingTime < options.MinDelay || remainingTime <= 0 {
break
}
// compute exponential backoff between waiter retries
delay, err := smithywaiter.ComputeDelay(
attempt, options.MinDelay, options.MaxDelay, remainingTime,
)
if err != nil {
return nil, fmt.Errorf("error computing waiter delay, %w", err)
}
remainingTime -= delay
// sleep for the delay amount before invoking a request
if err := smithytime.SleepWithContext(ctx, delay); err != nil {
return nil, fmt.Errorf("request cancelled while waiting, %w", err)
}
}
return nil, fmt.Errorf("exceeded max wait time for ImageVersionCreated waiter")
}
func imageVersionCreatedStateRetryable(ctx context.Context, input *DescribeImageVersionInput, output *DescribeImageVersionOutput, err error) (bool, error) {
if err == nil {
pathValue, err := jmespath.Search("ImageVersionStatus", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "CREATED"
value, ok := pathValue.(types.ImageVersionStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.ImageVersionStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("ImageVersionStatus", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "CREATE_FAILED"
value, ok := pathValue.(types.ImageVersionStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.ImageVersionStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, fmt.Errorf("waiter state transitioned to Failure")
}
}
if err != nil {
var apiErr smithy.APIError
ok := errors.As(err, &apiErr)
if !ok {
return false, fmt.Errorf("expected err to be of type smithy.APIError, got %w", err)
}
if "ValidationException" == apiErr.ErrorCode() {
return false, fmt.Errorf("waiter state transitioned to Failure")
}
}
return true, nil
}
// ImageVersionDeletedWaiterOptions are waiter options for
// ImageVersionDeletedWaiter
type ImageVersionDeletedWaiterOptions 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
// MinDelay is the minimum amount of time to delay between retries. If unset,
// ImageVersionDeletedWaiter will use default minimum delay of 60 seconds. Note
// that MinDelay must resolve to a value lesser than or equal to the MaxDelay.
MinDelay time.Duration
// MaxDelay is the maximum amount of time to delay between retries. If unset or
// set to zero, ImageVersionDeletedWaiter will use default max delay of 120
// seconds. Note that MaxDelay must resolve to value greater than or equal to the
// MinDelay.
MaxDelay time.Duration
// LogWaitAttempts is used to enable logging for waiter retry attempts
LogWaitAttempts bool
// Retryable is function that can be used to override the service defined
// waiter-behavior based on operation output, or returned error. This function is
// used by the waiter to decide if a state is retryable or a terminal state. By
// default service-modeled logic will populate this option. This option can thus be
// used to define a custom waiter state with fall-back to service-modeled waiter
// state mutators.The function returns an error in case of a failure state. In case
// of retry state, this function returns a bool value of true and nil error, while
// in case of success it returns a bool value of false and nil error.
Retryable func(context.Context, *DescribeImageVersionInput, *DescribeImageVersionOutput, error) (bool, error)
}
// ImageVersionDeletedWaiter defines the waiters for ImageVersionDeleted
type ImageVersionDeletedWaiter struct {
client DescribeImageVersionAPIClient
options ImageVersionDeletedWaiterOptions
}
// NewImageVersionDeletedWaiter constructs a ImageVersionDeletedWaiter.
func NewImageVersionDeletedWaiter(client DescribeImageVersionAPIClient, optFns ...func(*ImageVersionDeletedWaiterOptions)) *ImageVersionDeletedWaiter {
options := ImageVersionDeletedWaiterOptions{}
options.MinDelay = 60 * time.Second
options.MaxDelay = 120 * time.Second
options.Retryable = imageVersionDeletedStateRetryable
for _, fn := range optFns {
fn(&options)
}
return &ImageVersionDeletedWaiter{
client: client,
options: options,
}
}
// Wait calls the waiter function for ImageVersionDeleted waiter. The maxWaitDur
// is the maximum wait duration the waiter will wait. The maxWaitDur is required
// and must be greater than zero.
func (w *ImageVersionDeletedWaiter) Wait(ctx context.Context, params *DescribeImageVersionInput, maxWaitDur time.Duration, optFns ...func(*ImageVersionDeletedWaiterOptions)) error {
_, err := w.WaitForOutput(ctx, params, maxWaitDur, optFns...)
return err
}
// WaitForOutput calls the waiter function for ImageVersionDeleted waiter and
// returns the output of the successful operation. The maxWaitDur is the maximum
// wait duration the waiter will wait. The maxWaitDur is required and must be
// greater than zero.
func (w *ImageVersionDeletedWaiter) WaitForOutput(ctx context.Context, params *DescribeImageVersionInput, maxWaitDur time.Duration, optFns ...func(*ImageVersionDeletedWaiterOptions)) (*DescribeImageVersionOutput, error) {
if maxWaitDur <= 0 {
return nil, fmt.Errorf("maximum wait time for waiter must be greater than zero")
}
options := w.options
for _, fn := range optFns {
fn(&options)
}
if options.MaxDelay <= 0 {
options.MaxDelay = 120 * time.Second
}
if options.MinDelay > options.MaxDelay {
return nil, fmt.Errorf("minimum waiter delay %v must be lesser than or equal to maximum waiter delay of %v.", options.MinDelay, options.MaxDelay)
}
ctx, cancelFn := context.WithTimeout(ctx, maxWaitDur)
defer cancelFn()
logger := smithywaiter.Logger{}
remainingTime := maxWaitDur
var attempt int64
for {
attempt++
apiOptions := options.APIOptions
start := time.Now()
if options.LogWaitAttempts {
logger.Attempt = attempt
apiOptions = append([]func(*middleware.Stack) error{}, options.APIOptions...)
apiOptions = append(apiOptions, logger.AddLogger)
}
out, err := w.client.DescribeImageVersion(ctx, params, func(o *Options) {
o.APIOptions = append(o.APIOptions, apiOptions...)
})
retryable, err := options.Retryable(ctx, params, out, err)
if err != nil {
return nil, err
}
if !retryable {
return out, nil
}
remainingTime -= time.Since(start)
if remainingTime < options.MinDelay || remainingTime <= 0 {
break
}
// compute exponential backoff between waiter retries
delay, err := smithywaiter.ComputeDelay(
attempt, options.MinDelay, options.MaxDelay, remainingTime,
)
if err != nil {
return nil, fmt.Errorf("error computing waiter delay, %w", err)
}
remainingTime -= delay
// sleep for the delay amount before invoking a request
if err := smithytime.SleepWithContext(ctx, delay); err != nil {
return nil, fmt.Errorf("request cancelled while waiting, %w", err)
}
}
return nil, fmt.Errorf("exceeded max wait time for ImageVersionDeleted waiter")
}
func imageVersionDeletedStateRetryable(ctx context.Context, input *DescribeImageVersionInput, output *DescribeImageVersionOutput, err error) (bool, error) {
if err != nil {
var apiErr smithy.APIError
ok := errors.As(err, &apiErr)
if !ok {
return false, fmt.Errorf("expected err to be of type smithy.APIError, got %w", err)
}
if "ResourceNotFoundException" == apiErr.ErrorCode() {
return false, nil
}
}
if err == nil {
pathValue, err := jmespath.Search("ImageVersionStatus", output)
if err != nil {
return false, fmt.Errorf("error evaluating waiter state: %w", err)
}
expectedValue := "DELETE_FAILED"
value, ok := pathValue.(types.ImageVersionStatus)
if !ok {
return false, fmt.Errorf("waiter comparator expected types.ImageVersionStatus value, got %T", pathValue)
}
if string(value) == expectedValue {
return false, fmt.Errorf("waiter state transitioned to Failure")
}
}
if err != nil {
var apiErr smithy.APIError
ok := errors.As(err, &apiErr)
if !ok {
return false, fmt.Errorf("expected err to be of type smithy.APIError, got %w", err)
}
if "ValidationException" == apiErr.ErrorCode() {
return false, fmt.Errorf("waiter state transitioned to Failure")
}
}
return true, nil
}
func newServiceMetadataMiddleware_opDescribeImageVersion(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
SigningName: "sagemaker",
OperationName: "DescribeImageVersion",
}
}
| 582 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.