aws-sdk-sagemaker 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8f0564c7675ae297473f59bd72e0f9bb2978e984
-  data.tar.gz: 14448b9c8a2ec9fd66186ac8e26732eac7935bb7
+  metadata.gz: 1f5ac5df89d71df99d66eedf98b95157073060d7
+  data.tar.gz: c5e7233229ee3f5e42171be75f025802af28a889
 SHA512:
-  metadata.gz: ad400d24531bf38d4f23293535811377bf9fd7f6e1ec7b1dcb94161fa2ad6ba6b00d92af99448ee1c4090a3be8d58cb288811610cb92e48f0faf76b060ee29a1
-  data.tar.gz: 16485545a89acf71adb536ff1aba4e00f635ef657619b6fbbaaebbf79ac82817d490a5dd8249bbd66823bba8afc966d0cb624013d7551bd46bcbf8f1eabfdd4c
+  metadata.gz: 8b3be42afcef637ac2ff638449e73e871a9c278091650990c571312091354b4d0cbe8e4c4adc62a87ddeeefc3e6f680a48f3d99ea4a9e3904813b3e65a1eb143
+  data.tar.gz: f0ef76def9613b4a79c0d53c34a84f8958ed57bfc2012a3615feffc7c351586da8c5587bd5cb76a960fee18f53002686ac08734e1d5e65aea2396b0e872e2636

data/lib/aws-sdk-sagemaker.rb

@@ -43,6 +43,6 @@ require_relative 'aws-sdk-sagemaker/customizations'
 # @service
 module Aws::SageMaker
 
-  GEM_VERSION = '1.0.0'
+  GEM_VERSION = '1.1.0'
 
 end

data/lib/aws-sdk-sagemaker/client.rb

@@ -1876,143 +1876,14 @@ module Aws::SageMaker
         params: params,
         config: config)
       context[:gem_name] = 'aws-sdk-sagemaker'
-      context[:gem_version] = '1.0.0'
+      context[:gem_version] = '1.1.0'
       Seahorse::Client::Request.new(handlers, context)
     end
 
-    # Polls an API operation until a resource enters a desired state.
-    #
-    # ## Basic Usage
-    #
-    # A waiter will call an API operation until:
-    #
-    # * It is successful
-    # * It enters a terminal state
-    # * It makes the maximum number of attempts
-    #
-    # In between attempts, the waiter will sleep.
-    #
-    #     # polls in a loop, sleeping between attempts
-    #     client.waiter_until(waiter_name, params)
-    #
-    # ## Configuration
-    #
-    # You can configure the maximum number of polling attempts, and the
-    # delay (in seconds) between each polling attempt. You can pass
-    # configuration as the final arguments hash.
-    #
-    #     # poll for ~25 seconds
-    #     client.wait_until(waiter_name, params, {
-    #       max_attempts: 5,
-    #       delay: 5,
-    #     })
-    #
-    # ## Callbacks
-    #
-    # You can be notified before each polling attempt and before each
-    # delay. If you throw `:success` or `:failure` from these callbacks,
-    # it will terminate the waiter.
-    #
-    #     started_at = Time.now
-    #     client.wait_until(waiter_name, params, {
-    #
-    #       # disable max attempts
-    #       max_attempts: nil,
-    #
-    #       # poll for 1 hour, instead of a number of attempts
-    #       before_wait: -> (attempts, response) do
-    #         throw :failure if Time.now - started_at > 3600
-    #       end
-    #     })
-    #
-    # ## Handling Errors
-    #
-    # When a waiter is unsuccessful, it will raise an error.
-    # All of the failure errors extend from
-    # {Aws::Waiters::Errors::WaiterFailed}.
-    #
-    #     begin
-    #       client.wait_until(...)
-    #     rescue Aws::Waiters::Errors::WaiterFailed
-    #       # resource did not enter the desired state in time
-    #     end
-    #
-    # ## Valid Waiters
-    #
-    # The following table lists the valid waiter names, the operations they call,
-    # and the default `:delay` and `:max_attempts` values.
-    #
-    # | waiter_name               | params                        | :delay   | :max_attempts |
-    # | ------------------------- | ----------------------------- | -------- | ------------- |
-    # | endpoint_created          | {#describe_endpoint}          | 120      | 120           |
-    # | endpoint_deleted          | {#describe_endpoint}          | 120      | 120           |
-    # | endpoint_updated          | {#describe_endpoint}          | 120      | 120           |
-    # | notebook_instance_deleted | {#describe_notebook_instance} | 120      | 120           |
-    # | notebook_instance_running | {#describe_notebook_instance} | 120      | 120           |
-    # | notebook_instance_stopped | {#describe_notebook_instance} | 120      | 120           |
-    # | training_job_created      | {#describe_training_job}      | 120      | 120           |
-    # | training_job_deleted      | {#describe_training_job}      | 120      | 120           |
-    # | training_job_stopped      | {#describe_training_job}      | 120      | 120           |
-    #
-    # @raise [Errors::FailureStateError] Raised when the waiter terminates
-    #   because the waiter has entered a state that it will not transition
-    #   out of, preventing success.
-    #
-    # @raise [Errors::TooManyAttemptsError] Raised when the configured
-    #   maximum number of attempts have been made, and the waiter is not
-    #   yet successful.
-    #
-    # @raise [Errors::UnexpectedError] Raised when an error is encounted
-    #   while polling for a resource that is not expected.
-    #
-    # @raise [Errors::NoSuchWaiterError] Raised when you request to wait
-    #   for an unknown state.
-    #
-    # @return [Boolean] Returns `true` if the waiter was successful.
-    # @param [Symbol] waiter_name
-    # @param [Hash] params ({})
-    # @param [Hash] options ({})
-    # @option options [Integer] :max_attempts
-    # @option options [Integer] :delay
-    # @option options [Proc] :before_attempt
-    # @option options [Proc] :before_wait
-    def wait_until(waiter_name, params = {}, options = {})
-      w = waiter(waiter_name, options)
-      yield(w.waiter) if block_given? # deprecated
-      w.wait(params)
-    end
-
     # @api private
     # @deprecated
     def waiter_names
-      waiters.keys
-    end
-
-    private
-
-    # @param [Symbol] waiter_name
-    # @param [Hash] options ({})
-    def waiter(waiter_name, options = {})
-      waiter_class = waiters[waiter_name]
-      if waiter_class
-        waiter_class.new(options.merge(client: self))
-      else
-        raise Aws::Waiters::Errors::NoSuchWaiterError.new(waiter_name, waiters.keys)
-      end
-    end
-
-    def waiters
-      {
-        endpoint_created: Waiters::Endpoint_Created,
-        endpoint_deleted: Waiters::Endpoint_Deleted,
-        endpoint_updated: Waiters::Endpoint_Updated,
-        notebook_instance_deleted: Waiters::NotebookInstance_Deleted,
-        notebook_instance_running: Waiters::NotebookInstance_Running,
-        notebook_instance_stopped: Waiters::NotebookInstance_Stopped,
-        training_job_created: Waiters::TrainingJob_Created,
-        training_job_deleted: Waiters::TrainingJob_Deleted,
-        training_job_stopped: Waiters::TrainingJob_Stopped
-      }
+      []
     end
 
     class << self

data/lib/aws-sdk-sagemaker/waiters.rb

@@ -9,559 +9,5 @@ require 'aws-sdk-core/waiters'
 
 module Aws::SageMaker
   module Waiters
-
-    class Endpoint_Created
-
-      # @param [Hash] options
-      # @option options [required, Client] :client
-      # @option options [Integer] :max_attempts (120)
-      # @option options [Integer] :delay (120)
-      # @option options [Proc] :before_attempt
-      # @option options [Proc] :before_wait
-      def initialize(options)
-        @client = options.fetch(:client)
-        @waiter = Aws::Waiters::Waiter.new({
-          max_attempts: 120,
-          delay: 120,
-          poller: Aws::Waiters::Poller.new(
-            operation_name: :describe_endpoint,
-            acceptors: [
-              {
-                "expected" => "InService",
-                "matcher" => "path",
-                "state" => "success",
-                "argument" => "endpoint_status"
-              },
-              {
-                "expected" => "Creating",
-                "matcher" => "path",
-                "state" => "retry",
-                "argument" => "endpoint_status"
-              },
-              {
-                "expected" => "Failed",
-                "matcher" => "path",
-                "state" => "failure",
-                "argument" => "endpoint_status"
-              },
-              {
-                "expected" => "ThrottlingException",
-                "matcher" => "error",
-                "state" => "retry"
-              },
-              {
-                "expected" => "ValidationException",
-                "matcher" => "error",
-                "state" => "failure"
-              }
-            ]
-          )
-        }.merge(options))
-      end
-
-      # @option (see Client#describe_endpoint)
-      # @return (see Client#describe_endpoint)
-      def wait(params = {})
-        @waiter.wait(client: @client, params: params)
-      end
-
-      # @api private
-      attr_reader :waiter
-
-    end
-
-    class Endpoint_Deleted
-
-      # @param [Hash] options
-      # @option options [required, Client] :client
-      # @option options [Integer] :max_attempts (120)
-      # @option options [Integer] :delay (120)
-      # @option options [Proc] :before_attempt
-      # @option options [Proc] :before_wait
-      def initialize(options)
-        @client = options.fetch(:client)
-        @waiter = Aws::Waiters::Waiter.new({
-          max_attempts: 120,
-          delay: 120,
-          poller: Aws::Waiters::Poller.new(
-            operation_name: :describe_endpoint,
-            acceptors: [
-              {
-                "expected" => "ValidationException",
-                "matcher" => "error",
-                "state" => "success"
-              },
-              {
-                "expected" => "Deleting",
-                "matcher" => "path",
-                "state" => "retry",
-                "argument" => "endpoint_status"
-              },
-              {
-                "expected" => "Failed",
-                "matcher" => "path",
-                "state" => "failure",
-                "argument" => "endpoint_status"
-              },
-              {
-                "expected" => "ThrottlingException",
-                "matcher" => "error",
-                "state" => "retry"
-              }
-            ]
-          )
-        }.merge(options))
-      end
-
-      # @option (see Client#describe_endpoint)
-      # @return (see Client#describe_endpoint)
-      def wait(params = {})
-        @waiter.wait(client: @client, params: params)
-      end
-
-      # @api private
-      attr_reader :waiter
-
-    end
-
-    class Endpoint_Updated
-
-      # @param [Hash] options
-      # @option options [required, Client] :client
-      # @option options [Integer] :max_attempts (120)
-      # @option options [Integer] :delay (120)
-      # @option options [Proc] :before_attempt
-      # @option options [Proc] :before_wait
-      def initialize(options)
-        @client = options.fetch(:client)
-        @waiter = Aws::Waiters::Waiter.new({
-          max_attempts: 120,
-          delay: 120,
-          poller: Aws::Waiters::Poller.new(
-            operation_name: :describe_endpoint,
-            acceptors: [
-              {
-                "expected" => "200",
-                "matcher" => "path",
-                "state" => "success",
-                "argument" => "endpoint_name"
-              },
-              {
-                "expected" => "Updating",
-                "matcher" => "path",
-                "state" => "retry",
-                "argument" => "endpoint_status"
-              },
-              {
-                "expected" => "RollingBack",
-                "matcher" => "path",
-                "state" => "retry",
-                "argument" => "endpoint_status"
-              },
-              {
-                "expected" => "Failed",
-                "matcher" => "path",
-                "state" => "failure",
-                "argument" => "endpoint_status"
-              },
-              {
-                "expected" => "ThrottlingException",
-                "matcher" => "error",
-                "state" => "retry"
-              },
-              {
-                "expected" => "ValidationException",
-                "matcher" => "error",
-                "state" => "retry"
-              }
-            ]
-          )
-        }.merge(options))
-      end
-
-      # @option (see Client#describe_endpoint)
-      # @return (see Client#describe_endpoint)
-      def wait(params = {})
-        @waiter.wait(client: @client, params: params)
-      end
-
-      # @api private
-      attr_reader :waiter
-
-    end
-
-    class NotebookInstance_Deleted
-
-      # @param [Hash] options
-      # @option options [required, Client] :client
-      # @option options [Integer] :max_attempts (120)
-      # @option options [Integer] :delay (120)
-      # @option options [Proc] :before_attempt
-      # @option options [Proc] :before_wait
-      def initialize(options)
-        @client = options.fetch(:client)
-        @waiter = Aws::Waiters::Waiter.new({
-          max_attempts: 120,
-          delay: 120,
-          poller: Aws::Waiters::Poller.new(
-            operation_name: :describe_notebook_instance,
-            acceptors: [
-              {
-                "expected" => "ValidationException",
-                "matcher" => "error",
-                "state" => "success"
-              },
-              {
-                "expected" => "Deleting",
-                "matcher" => "path",
-                "state" => "retry",
-                "argument" => "notebook_instance_status"
-              },
-              {
-                "expected" => "ThrottlingException",
-                "matcher" => "error",
-                "state" => "retry"
-              },
-              {
-                "expected" => "Failed",
-                "matcher" => "path",
-                "state" => "failure",
-                "argument" => "notebook_instance_status"
-              }
-            ]
-          )
-        }.merge(options))
-      end
-
-      # @option (see Client#describe_notebook_instance)
-      # @return (see Client#describe_notebook_instance)
-      def wait(params = {})
-        @waiter.wait(client: @client, params: params)
-      end
-
-      # @api private
-      attr_reader :waiter
-
-    end
-
-    class NotebookInstance_Running
-
-      # @param [Hash] options
-      # @option options [required, Client] :client
-      # @option options [Integer] :max_attempts (120)
-      # @option options [Integer] :delay (120)
-      # @option options [Proc] :before_attempt
-      # @option options [Proc] :before_wait
-      def initialize(options)
-        @client = options.fetch(:client)
-        @waiter = Aws::Waiters::Waiter.new({
-          max_attempts: 120,
-          delay: 120,
-          poller: Aws::Waiters::Poller.new(
-            operation_name: :describe_notebook_instance,
-            acceptors: [
-              {
-                "expected" => "InService",
-                "matcher" => "path",
-                "state" => "success",
-                "argument" => "notebook_instance_status"
-              },
-              {
-                "expected" => "ThrottlingException",
-                "matcher" => "error",
-                "state" => "retry"
-              },
-              {
-                "expected" => "Failed",
-                "matcher" => "path",
-                "state" => "failure",
-                "argument" => "notebook_instance_status"
-              },
-              {
-                "expected" => "Stopped",
-                "matcher" => "path",
-                "state" => "failure",
-                "argument" => "notebook_instance_status"
-              },
-              {
-                "expected" => "Stopping",
-                "matcher" => "path",
-                "state" => "failure",
-                "argument" => "notebook_instance_status"
-              }
-            ]
-          )
-        }.merge(options))
-      end
-
-      # @option (see Client#describe_notebook_instance)
-      # @return (see Client#describe_notebook_instance)
-      def wait(params = {})
-        @waiter.wait(client: @client, params: params)
-      end
-
-      # @api private
-      attr_reader :waiter
-
-    end
-
-    class NotebookInstance_Stopped
-
-      # @param [Hash] options
-      # @option options [required, Client] :client
-      # @option options [Integer] :max_attempts (120)
-      # @option options [Integer] :delay (120)
-      # @option options [Proc] :before_attempt
-      # @option options [Proc] :before_wait
-      def initialize(options)
-        @client = options.fetch(:client)
-        @waiter = Aws::Waiters::Waiter.new({
-          max_attempts: 120,
-          delay: 120,
-          poller: Aws::Waiters::Poller.new(
-            operation_name: :describe_notebook_instance,
-            acceptors: [
-              {
-                "expected" => "Stopped",
-                "matcher" => "path",
-                "state" => "success",
-                "argument" => "notebook_instance_status"
-              },
-              {
-                "expected" => "Stopping",
-                "matcher" => "path",
-                "state" => "retry",
-                "argument" => "notebook_instance_status"
-              },
-              {
-                "expected" => "ThrottlingException",
-                "matcher" => "error",
-                "state" => "retry"
-              },
-              {
-                "expected" => "Failed",
-                "matcher" => "path",
-                "state" => "failure",
-                "argument" => "notebook_instance_status"
-              }
-            ]
-          )
-        }.merge(options))
-      end
-
-      # @option (see Client#describe_notebook_instance)
-      # @return (see Client#describe_notebook_instance)
-      def wait(params = {})
-        @waiter.wait(client: @client, params: params)
-      end
-
-      # @api private
-      attr_reader :waiter
-
-    end
-
-    class TrainingJob_Created
-
-      # @param [Hash] options
-      # @option options [required, Client] :client
-      # @option options [Integer] :max_attempts (120)
-      # @option options [Integer] :delay (120)
-      # @option options [Proc] :before_attempt
-      # @option options [Proc] :before_wait
-      def initialize(options)
-        @client = options.fetch(:client)
-        @waiter = Aws::Waiters::Waiter.new({
-          max_attempts: 120,
-          delay: 120,
-          poller: Aws::Waiters::Poller.new(
-            operation_name: :describe_training_job,
-            acceptors: [
-              {
-                "expected" => "Created",
-                "matcher" => "path",
-                "state" => "success",
-                "argument" => "training_job_status"
-              },
-              {
-                "expected" => "Completed",
-                "matcher" => "path",
-                "state" => "success",
-                "argument" => "training_job_status"
-              },
-              {
-                "expected" => "InProgress",
-                "matcher" => "path",
-                "state" => "retry",
-                "argument" => "training_job_status"
-              },
-              {
-                "expected" => "Failed",
-                "matcher" => "path",
-                "state" => "failure",
-                "argument" => "training_job_status"
-              },
-              {
-                "expected" => "Stopping",
-                "matcher" => "path",
-                "state" => "failure",
-                "argument" => "training_job_status"
-              },
-              {
-                "expected" => "Stopped",
-                "matcher" => "path",
-                "state" => "failure",
-                "argument" => "training_job_status"
-              },
-              {
-                "expected" => "Deleting",
-                "matcher" => "path",
-                "state" => "failure",
-                "argument" => "training_job_status"
-              },
-              {
-                "expected" => "ValidationException",
-                "matcher" => "error",
-                "state" => "failure"
-              },
-              {
-                "expected" => "ThrottlingException",
-                "matcher" => "error",
-                "state" => "retry"
-              }
-            ]
-          )
-        }.merge(options))
-      end
-
-      # @option (see Client#describe_training_job)
-      # @return (see Client#describe_training_job)
-      def wait(params = {})
-        @waiter.wait(client: @client, params: params)
-      end
-
-      # @api private
-      attr_reader :waiter
-
-    end
-
-    class TrainingJob_Deleted
-
-      # @param [Hash] options
-      # @option options [required, Client] :client
-      # @option options [Integer] :max_attempts (120)
-      # @option options [Integer] :delay (120)
-      # @option options [Proc] :before_attempt
-      # @option options [Proc] :before_wait
-      def initialize(options)
-        @client = options.fetch(:client)
-        @waiter = Aws::Waiters::Waiter.new({
-          max_attempts: 120,
-          delay: 120,
-          poller: Aws::Waiters::Poller.new(
-            operation_name: :describe_training_job,
-            acceptors: [
-              {
-                "expected" => "ValidationException",
-                "matcher" => "error",
-                "state" => "success"
-              },
-              {
-                "expected" => "Deleting",
-                "matcher" => "path",
-                "state" => "retry",
-                "argument" => "training_job_status"
-              },
-              {
-                "expected" => "ThrottlingException",
-                "matcher" => "error",
-                "state" => "retry"
-              }
-            ]
-          )
-        }.merge(options))
-      end
-
-      # @option (see Client#describe_training_job)
-      # @return (see Client#describe_training_job)
-      def wait(params = {})
-        @waiter.wait(client: @client, params: params)
-      end
-
-      # @api private
-      attr_reader :waiter
-
-    end
-
-    class TrainingJob_Stopped
-
-      # @param [Hash] options
-      # @option options [required, Client] :client
-      # @option options [Integer] :max_attempts (120)
-      # @option options [Integer] :delay (120)
-      # @option options [Proc] :before_attempt
-      # @option options [Proc] :before_wait
-      def initialize(options)
-        @client = options.fetch(:client)
-        @waiter = Aws::Waiters::Waiter.new({
-          max_attempts: 120,
-          delay: 120,
-          poller: Aws::Waiters::Poller.new(
-            operation_name: :describe_training_job,
-            acceptors: [
-              {
-                "expected" => "Completed",
-                "matcher" => "path",
-                "state" => "success",
-                "argument" => "training_job_status"
-              },
-              {
-                "expected" => "Stopping",
-                "matcher" => "path",
-                "state" => "retry",
-                "argument" => "training_job_status"
-              },
-              {
-                "expected" => "Stopped",
-                "matcher" => "path",
-                "state" => "success",
-                "argument" => "training_job_status"
-              },
-              {
-                "expected" => "ThrottlingException",
-                "matcher" => "error",
-                "state" => "retry"
-              },
-              {
-                "expected" => "ValidationException",
-                "matcher" => "error",
-                "state" => "failure"
-              },
-              {
-                "expected" => "Failed",
-                "matcher" => "path",
-                "state" => "failure",
-                "argument" => "training_job_status"
-              },
-              {
-                "expected" => "Deleting",
-                "matcher" => "path",
-                "state" => "failure",
-                "argument" => "training_job_status"
-              }
-            ]
-          )
-        }.merge(options))
-      end
-
-      # @option (see Client#describe_training_job)
-      # @return (see Client#describe_training_job)
-      def wait(params = {})
-        @waiter.wait(client: @client, params: params)
-      end
-
-      # @api private
-      attr_reader :waiter
-
-    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aws-sdk-sagemaker
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Amazon Web Services
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-29 00:00:00.000000000 Z
+date: 2017-12-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-core