algolia 3.43.0 → 3.46.1

data/lib/algolia/api/search_client.rb

@@ -9,7 +9,7 @@ module Algolia
   # Configuration options for the ingestion transporter used by *_with_transformation helpers.
   # When passed to SearchClient.with_transformation or set via set_transformation_options,
   # the ingestion transporter is eagerly created using Ingestion API defaults (25s timeouts,
-  # no compression). Only fields explicitly set here override those defaults.
+  # no compression, 3 waits on HTTP 429). Only fields explicitly set here override those defaults.
   # See https://www.algolia.com/doc/libraries/ruby/v3/methods/ingestion
   class TransformationOptions
     attr_accessor(
@@ -19,7 +19,8 @@ module Algolia
       :write_timeout,
       :hosts,
       :compression_type,
-      :header_params
+      :header_params,
+      :max_rate_limit_retries
     )
 
     def initialize(region, opts = {})
@@ -30,7 +31,15 @@ module Algolia
         )
       end
 
-      valid_keys = %i[connect_timeout read_timeout write_timeout hosts compression_type header_params]
+      valid_keys = %i[
+        connect_timeout
+        read_timeout
+        write_timeout
+        hosts
+        compression_type
+        header_params
+        max_rate_limit_retries
+      ]
       unknown = opts.keys - valid_keys
       unless unknown.empty?
         raise(
@@ -46,6 +55,7 @@ module Algolia
       @hosts = opts[:hosts]
       @compression_type = opts[:compression_type]
       @header_params = opts[:header_params]
+      @max_rate_limit_retries = opts[:max_rate_limit_retries]
     end
   end
 
@@ -69,7 +79,8 @@ module Algolia
         config.write_timeout = 30000
       end
 
-      @api_client = Algolia::ApiClient.new(config)
+      # Per-client capability; an explicit config.request_id_enabled always wins.
+      @api_client = Algolia::ApiClient.new(config, request_id_support: true)
       @ingestion_transporter = nil
       if config.transformation_options
         @ingestion_transporter = _build_ingestion_transporter(config.transformation_options)
@@ -3412,6 +3423,42 @@ module Algolia
       @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::UpdateApiKeyResponse")
     end
 
+    # Helper: Derives the request options carrying the Request-ID shared by every request
+    # of one helper invocation. Returns the options untouched when the client does not
+    # support Request-ID or the caller already supplied one through the options (as a
+    # header or an x-algolia-request-id query parameter) or the config headers, which
+    # also makes nested helpers reuse the ID minted by their caller.
+    #
+    # @param request_options [Hash]
+    #
+    # @return [Hash]
+    private def with_request_id(request_options = {})
+      config = api_client.config
+      unless api_client.request_id_enabled? &&
+          !Transport::RequestId.request_id?(request_options[:header_params]) &&
+          !Transport::RequestId.request_id?(config.header_params) &&
+          !Transport::RequestId.request_id_query_param?(request_options[:query_params])
+        return request_options
+      end
+
+      request_options.merge(
+        :header_params => (request_options[:header_params] || {}).merge(
+          Transport::RequestId::HEADER => Transport::RequestId.generate
+        )
+      )
+    end
+
+    # Helper: Drops the caller's timeouts from the given request options, so that the
+    # failure-path cleanup calls run with the client defaults while keeping the other
+    # options, notably the headers carrying the invocation's shared Request-ID.
+    #
+    # @param request_options [Hash]
+    #
+    # @return [Hash]
+    private def without_timeouts(request_options)
+      request_options.reject { |key, _| key == :timeout || key == :connect_timeout }
+    end
+
     # The parent search config MUST NOT leak into the ingestion transporter.
     def _build_ingestion_transporter(transformation_options)
       hosts = if transformation_options.hosts
@@ -3436,6 +3483,10 @@ module Algolia
         opts[:compression_type] = transformation_options.compression_type
       end
 
+      unless transformation_options.max_rate_limit_retries.nil?
+        opts[:max_rate_limit_retries] = transformation_options.max_rate_limit_retries
+      end
+
       config = Algolia::Configuration.new(
         @api_client.config.app_id,
         @api_client.config.api_key,
@@ -3561,6 +3612,10 @@ module Algolia
     )
       assert_ingestion_transporter!
 
+      # The shared Request-ID only covers the search-side calls: the ingestion
+      # push goes to an API that must not receive the header.
+      search_request_options = with_request_id(request_options)
+
       if objects.empty?
         @api_client.logger.warn(
           "replace_all_objects_with_transformation was called with an empty list of objects, which will delete all records currently in the \"#{index_name}\" index."
@@ -3581,7 +3636,7 @@ module Algolia
             destination: tmp_index_name,
             scope: scopes
           ),
-          request_options
+          search_request_options
         )
 
         watch_responses = @ingestion_transporter.chunked_push(
@@ -3595,7 +3650,13 @@ module Algolia
           opts
         )
 
-        wait_for_task(tmp_index_name, copy_operation_response.task_id, opts.max_retries)
+        wait_for_task(
+          tmp_index_name,
+          copy_operation_response.task_id,
+          opts.max_retries,
+          Algolia::ChunkedHelperOptions::DEFAULT_TIMEOUT,
+          search_request_options
+        )
 
         copy_operation_response = operation_index(
           index_name,
@@ -3604,10 +3665,16 @@ module Algolia
             destination: tmp_index_name,
             scope: scopes
           ),
-          request_options
+          search_request_options
         )
 
-        wait_for_task(tmp_index_name, copy_operation_response.task_id, opts.max_retries)
+        wait_for_task(
+          tmp_index_name,
+          copy_operation_response.task_id,
+          opts.max_retries,
+          Algolia::ChunkedHelperOptions::DEFAULT_TIMEOUT,
+          search_request_options
+        )
 
         move_operation_response = operation_index(
           tmp_index_name,
@@ -3615,10 +3682,16 @@ module Algolia
             operation: Search::OperationType::MOVE,
             destination: index_name
           ),
-          request_options
+          search_request_options
         )
 
-        wait_for_task(tmp_index_name, move_operation_response.task_id, opts.max_retries)
+        wait_for_task(
+          tmp_index_name,
+          move_operation_response.task_id,
+          opts.max_retries,
+          Algolia::ChunkedHelperOptions::DEFAULT_TIMEOUT,
+          search_request_options
+        )
 
         search_watch_responses = watch_responses.map do |wr|
           Search::WatchResponse.build_from_hash(wr.to_hash)
@@ -3630,7 +3703,13 @@ module Algolia
           move_operation_response: move_operation_response
         )
       rescue Exception => e
-        delete_index(tmp_index_name)
+        begin
+          delete_index(tmp_index_name, without_timeouts(search_request_options))
+        rescue StandardError => cleanup_error
+          @api_client.logger.warn(
+            "Failed to delete the temporary index \"#{tmp_index_name}\", please delete it manually: #{cleanup_error}"
+          )
+        end
 
         raise e
       end
@@ -3641,16 +3720,17 @@ module Algolia
     # @param index_name [String] the `index_name` where the operation was performed. (required)
     # @param task_id [Integer] the `task_id` returned in the method response. (required)
     # @param max_retries [Integer] the maximum number of retries. (optional, default to Algolia::ChunkedHelperOptions::DEFAULT_MAX_RETRIES)
-    # @param timeout [Proc] the function to decide how long to wait between retries. (optional)
+    # @param timeout [Proc] the function to decide how long to wait between retries. (optional, default to Algolia::ChunkedHelperOptions::DEFAULT_TIMEOUT)
     # @param request_options [Hash] the requestOptions to send along with the query, they will be forwarded to the `get_task` method.
     # @return [Http::Response] the last get_task response
     def wait_for_task(
       index_name,
       task_id,
       max_retries = Algolia::ChunkedHelperOptions::DEFAULT_MAX_RETRIES,
-      timeout = -> (retry_count) { [retry_count * 200, 5000].min },
+      timeout = Algolia::ChunkedHelperOptions::DEFAULT_TIMEOUT,
       request_options = {}
     )
+      request_options = with_request_id(request_options)
       retries = 0
       while retries < max_retries
         res = get_task(index_name, task_id, request_options)
@@ -3672,15 +3752,16 @@ module Algolia
     #
     # @param task_id [Integer] the `task_id` returned in the method response. (required)
     # @param max_retries [Integer] the maximum number of retries. (optional, default to Algolia::ChunkedHelperOptions::DEFAULT_MAX_RETRIES)
-    # @param timeout [Proc] the function to decide how long to wait between retries. (optional)
+    # @param timeout [Proc] the function to decide how long to wait between retries. (optional, default to Algolia::ChunkedHelperOptions::DEFAULT_TIMEOUT)
     # @param request_options [Hash] the requestOptions to send along with the query, they will be forwarded to the `get_task` method.
     # @return [Http::Response] the last get_task response
     def wait_for_app_task(
       task_id,
       max_retries = Algolia::ChunkedHelperOptions::DEFAULT_MAX_RETRIES,
-      timeout = -> (retry_count) { [retry_count * 200, 5000].min },
+      timeout = Algolia::ChunkedHelperOptions::DEFAULT_TIMEOUT,
       request_options = {}
     )
+      request_options = with_request_id(request_options)
       retries = 0
       while retries < max_retries
         res = get_app_task(task_id, request_options)
@@ -3703,8 +3784,8 @@ module Algolia
     # @param key [String] the `key` that has been added, deleted or updated.
     # @param operation [String] the `operation` that was done on a `key`.
     # @param api_key [Hash] necessary to know if an `update` operation has been processed, compare fields of the response with it.
-    # @param max_retries [Integer] the maximum number of retries.
-    # @param timeout [Proc] the function to decide how long to wait between retries.
+    # @param max_retries [Integer] the maximum number of retries. (optional, default to Algolia::ChunkedHelperOptions::DEFAULT_MAX_RETRIES)
+    # @param timeout [Proc] the function to decide how long to wait between retries. (optional, default to Algolia::ChunkedHelperOptions::DEFAULT_TIMEOUT)
     # @param request_options [Hash] the requestOptions to send along with the query, they will be forwarded to the `getApikey` method and merged with the transporter requestOptions.
     # @return [Http::Response] the last get_api_key response
     def wait_for_api_key(
@@ -3712,9 +3793,10 @@ module Algolia
       operation,
       api_key = Search::ApiKey.new,
       max_retries = Algolia::ChunkedHelperOptions::DEFAULT_MAX_RETRIES,
-      timeout = -> (retry_count) { [retry_count * 200, 5000].min },
+      timeout = Algolia::ChunkedHelperOptions::DEFAULT_TIMEOUT,
       request_options = {}
     )
+      request_options = with_request_id(request_options)
       api_key = api_client.object_to_hash(api_key)
 
       retries = 0
@@ -3769,6 +3851,7 @@ module Algolia
     # @param request_options [Hash] the requestOptions to send along with the query, they will be forwarded to the `browse` method.
     # @param block [Proc] the block to execute on each object of the index.
     def browse_objects(index_name, browse_params = Search::BrowseParamsObject.new, request_options = {}, &block)
+      request_options = with_request_id(request_options)
       browse_params = api_client.object_to_hash(browse_params)
 
       browse_params[:hitsPerPage] = 1000 unless browse_params.key?(:hitsPerPage)
@@ -3798,6 +3881,7 @@ module Algolia
     # @param request_options [Hash] the requestOptions to send along with the query, they will be forwarded to the `searchRules` method.
     # @param block [Proc] the block to execute on each rule of the index.
     def browse_rules(index_name, search_rules_params = Search::SearchRulesParams.new, request_options = {}, &block)
+      request_options = with_request_id(request_options)
       search_rules_params = api_client.object_to_hash(search_rules_params)
 
       search_rules_params[:page] ||= 0
@@ -3833,6 +3917,7 @@ module Algolia
       request_options = {},
       &block
     )
+      request_options = with_request_id(request_options)
       search_synonyms_params = api_client.object_to_hash(search_synonyms_params)
 
       search_synonyms_params[:page] ||= 0
@@ -4036,6 +4121,7 @@ module Algolia
       request_options = {},
       chunked_options = nil
     )
+      request_options = with_request_id(request_options)
       opts = Algolia::ChunkedHelperOptions.resolve(chunked_options)
       responses = []
       objects.each_slice(batch_size) do |chunk|
@@ -4048,7 +4134,13 @@ module Algolia
 
       if wait_for_tasks
         responses.each do |response|
-          wait_for_task(index_name, response.task_id, opts.max_retries)
+          wait_for_task(
+            index_name,
+            response.task_id,
+            opts.max_retries,
+            Algolia::ChunkedHelperOptions::DEFAULT_TIMEOUT,
+            request_options
+          )
         end
       end
 
@@ -4074,6 +4166,8 @@ module Algolia
       request_options = {},
       chunked_options = nil
     )
+      request_options = with_request_id(request_options)
+
       if objects.empty?
         @api_client.logger.warn(
           "replace_all_objects was called with an empty list of objects, which will delete all records currently in the \"#{index_name}\" index."
@@ -4107,7 +4201,13 @@ module Algolia
           opts
         )
 
-        wait_for_task(tmp_index_name, copy_operation_response.task_id, opts.max_retries)
+        wait_for_task(
+          tmp_index_name,
+          copy_operation_response.task_id,
+          opts.max_retries,
+          Algolia::ChunkedHelperOptions::DEFAULT_TIMEOUT,
+          request_options
+        )
 
         copy_operation_response = operation_index(
           index_name,
@@ -4119,7 +4219,13 @@ module Algolia
           request_options
         )
 
-        wait_for_task(tmp_index_name, copy_operation_response.task_id, opts.max_retries)
+        wait_for_task(
+          tmp_index_name,
+          copy_operation_response.task_id,
+          opts.max_retries,
+          Algolia::ChunkedHelperOptions::DEFAULT_TIMEOUT,
+          request_options
+        )
 
         move_operation_response = operation_index(
           tmp_index_name,
@@ -4130,7 +4236,13 @@ module Algolia
           request_options
         )
 
-        wait_for_task(tmp_index_name, move_operation_response.task_id, opts.max_retries)
+        wait_for_task(
+          tmp_index_name,
+          move_operation_response.task_id,
+          opts.max_retries,
+          Algolia::ChunkedHelperOptions::DEFAULT_TIMEOUT,
+          request_options
+        )
 
         Search::ReplaceAllObjectsResponse.new(
           copy_operation_response: copy_operation_response,
@@ -4138,7 +4250,13 @@ module Algolia
           move_operation_response: move_operation_response
         )
       rescue Exception => e
-        delete_index(tmp_index_name)
+        begin
+          delete_index(tmp_index_name, without_timeouts(request_options))
+        rescue StandardError => cleanup_error
+          @api_client.logger.warn(
+            "Failed to delete the temporary index \"#{tmp_index_name}\", please delete it manually: #{cleanup_error}"
+          )
+        end
 
         raise e
       end

data/lib/algolia/api_client.rb

@@ -13,11 +13,19 @@ module Algolia
 
     # Initializes the ApiClient
     # @option config [Configuration] Configuration for initializing the object, default to Configuration.default
-    def initialize(config = Configuration.default)
+    # @param request_id_support [true, false] the generated per-client Request-ID capability,
+    #   applied when config.request_id_enabled is nil. Kept on the transport so a shared Configuration is never mutated.
+    def initialize(config = Configuration.default, request_id_support: false)
       @config = config
       @requester = config.requester || Http::HttpRequester.new("net_http_persistent", LoggerHelper.create)
       @logger = (@requester.logger if @requester.respond_to?(:logger)) || LoggerHelper.create
-      @transporter = Transport::Transport.new(config, @requester)
+      @transporter = Transport::Transport.new(config, @requester, request_id_support: request_id_support)
+    end
+
+    # Whether the transport mints Request-ID headers, resolved per request.
+    # @return [true, false]
+    def request_id_enabled?
+      @transporter.request_id_enabled?
     end
 
     def self.default

data/lib/algolia/chunked_helper_options.rb

@@ -3,6 +3,7 @@ module Algolia
   class ChunkedHelperOptions
     DEFAULT_MAX_RETRIES = 100
     DEFAULT_REPLACE_ALL_OBJECTS_MAX_RETRIES = 800
+    DEFAULT_TIMEOUT = -> (retry_count) { [retry_count * 200, 5000].min }
     attr_reader :max_retries
 
     def initialize(max_retries: DEFAULT_MAX_RETRIES)

data/lib/algolia/configuration.rb

@@ -1,5 +1,3 @@
-# Code generated by OpenAPI Generator (https://openapi-generator.tech), manual changes will be lost - read more on https://github.com/algolia/api-clients-automation. DO NOT EDIT.
-
 module Algolia
   class Configuration
     attr_accessor(
@@ -21,6 +19,21 @@ module Algolia
     # @return [true, false]
     attr_accessor :client_side_validation
 
+    # Whether the transport sends a Request-ID header, minted once per call and
+    # reused across its retry attempts. When nil, each generated client applies its
+    # per-client default (on for the search, recommend and composition APIs, off
+    # elsewhere); an explicit true or false always wins and may be flipped at any
+    # time. A caller-supplied Request-ID is never overwritten.
+    # @return [true, false, nil]
+    attr_accessor :request_id_enabled
+
+    # How many times a 429 is waited out on the same host before it is raised.
+    # nil means Defaults::MAX_RATE_LIMIT_RETRIES (3); 0 fails on the first 429
+    # without waiting; a negative value behaves like 0. The wait is the Retry-After
+    # header in whole seconds, or 1 second when it is missing or invalid.
+    # @return [Integer, nil]
+    attr_accessor :max_rate_limit_retries
+
     def initialize(app_id, api_key, hosts, client_name, opts = {})
       @hosts = hosts
       @app_id = app_id
@@ -33,6 +46,9 @@ module Algolia
       @requester = opts[:requester]
       @transformation_options = opts[:transformation_options]
 
+      @request_id_enabled = opts[:request_id_enabled]
+      @max_rate_limit_retries = opts[:max_rate_limit_retries]
+
       @user_agent = UserAgent.new.add(client_name, VERSION)
 
       if opts[:user_agent_segments]

data/lib/algolia/defaults.rb

@@ -4,5 +4,13 @@ module Algolia
     READ_TIMEOUT = 5000
     WRITE_TIMEOUT = 30000
     CONNECT_TIMEOUT = 2000
+
+    # How many times a 429 is waited out on the same host before it is raised.
+    MAX_RATE_LIMIT_RETRIES = 3
+    # Seconds waited before a 429 retry when Retry-After is missing or invalid.
+    RATE_LIMIT_WAIT = 1
+    # Largest wait Kernel#sleep accepts (a 64-bit long, in seconds). A runtime
+    # ceiling like the Go and Swift clients', not a client-side maximum wait.
+    MAX_RATE_LIMIT_WAIT = 2 ** 63 - 1
   end
 end

data/lib/algolia/error.rb

@@ -12,13 +12,20 @@ module Algolia
   class AlgoliaUnreachableHostError < AlgoliaError
     attr_reader :errors
 
-    def initialize(message, errors = [])
+    # The last non-empty Correlation-ID header among the retried attempts, or nil.
+    # Quote it when contacting Algolia support.
+    attr_reader :correlation_id
+
+    def initialize(message, errors = [], correlation_id = nil)
       errors.last&.tap do |last_error|
         message += " Last error for #{last_error[:host]}: #{last_error[:error]}"
       end
 
+      message += " (Correlation-ID: #{correlation_id})" unless correlation_id.nil? || correlation_id.empty?
+
       super(message)
       @errors = errors
+      @correlation_id = correlation_id
     end
   end
 
@@ -29,10 +36,20 @@ module Algolia
   class AlgoliaHttpError < AlgoliaError
     attr_accessor :code, :http_message
 
-    def initialize(code, message)
+    # The Correlation-ID header of the failed response (possibly ""), or nil.
+    # Quote it when contacting Algolia support.
+    attr_reader :correlation_id
+
+    def initialize(code, message, correlation_id = nil)
       self.code = code
       self.http_message = message
-      super("#{code}: #{message}")
+      @correlation_id = correlation_id
+
+      if correlation_id.nil? || correlation_id.empty?
+        super("#{code}: #{message}")
+      else
+        super("#{code}: #{message} (Correlation-ID: #{correlation_id})")
+      end
     end
   end
 end

data/lib/algolia/models/abtesting-v3/ab_test.rb

@@ -26,6 +26,9 @@ module Algolia
       # A/B test name.
       attr_accessor :name
 
+      # Expected outcome of the A/B test.
+      attr_accessor :hypothesis
+
       attr_accessor :status
 
       # A/B test variants.  The first variant is your _control_ index, typically your production index. All of the additional variants are indexes with changed settings that you want to test against the control.
@@ -33,9 +36,6 @@ module Algolia
 
       attr_accessor :configuration
 
-      # Unique migrated A/B test identifier.
-      attr_accessor :migrated_ab_test_id
-
       attr_accessor :decision
 
       # Attribute mapping from ruby-style variable name to JSON key.
@@ -47,10 +47,10 @@ module Algolia
           :end_at => :endAt,
           :stopped_at => :stoppedAt,
           :name => :name,
+          :hypothesis => :hypothesis,
           :status => :status,
           :variants => :variants,
           :configuration => :configuration,
-          :migrated_ab_test_id => :migratedAbTestID,
           :decision => :decision
         }
       end
@@ -64,10 +64,10 @@ module Algolia
           :end_at => :"String",
           :stopped_at => :"String",
           :name => :"String",
+          :hypothesis => :"String",
           :status => :"Status",
           :variants => :"Array<Variant>",
           :configuration => :"ABTestConfiguration",
-          :migrated_ab_test_id => :"Integer",
           :decision => :"Decision"
         }
       end
@@ -135,6 +135,12 @@ module Algolia
           self.name = nil
         end
 
+        if attributes.key?(:hypothesis)
+          self.hypothesis = attributes[:hypothesis]
+        else
+          self.hypothesis = nil
+        end
+
         if attributes.key?(:status)
           self.status = attributes[:status]
         else
@@ -153,10 +159,6 @@ module Algolia
           self.configuration = attributes[:configuration]
         end
 
-        if attributes.key?(:migrated_ab_test_id)
-          self.migrated_ab_test_id = attributes[:migrated_ab_test_id]
-        end
-
         if attributes.key?(:decision)
           self.decision = attributes[:decision]
         end
@@ -173,10 +175,10 @@ module Algolia
           end_at == other.end_at &&
           stopped_at == other.stopped_at &&
           name == other.name &&
+          hypothesis == other.hypothesis &&
           status == other.status &&
           variants == other.variants &&
           configuration == other.configuration &&
-          migrated_ab_test_id == other.migrated_ab_test_id &&
           decision == other.decision
       end
 
@@ -196,10 +198,10 @@ module Algolia
           end_at,
           stopped_at,
           name,
+          hypothesis,
           status,
           variants,
           configuration,
-          migrated_ab_test_id,
           decision
         ].hash
       end

data/lib/algolia/models/abtesting-v3/ab_test_configuration.rb

@@ -16,12 +16,18 @@ module Algolia
 
       attr_accessor :error_correction
 
+      attr_accessor :method
+
+      attr_accessor :primary_metric
+
       # Attribute mapping from ruby-style variable name to JSON key.
       def self.attribute_map
         {
           :minimum_detectable_effect => :minimumDetectableEffect,
           :filters => :filters,
-          :error_correction => :errorCorrection
+          :error_correction => :errorCorrection,
+          :method => :method,
+          :primary_metric => :primaryMetric
         }
       end
 
@@ -30,7 +36,9 @@ module Algolia
         {
           :minimum_detectable_effect => :"MinimumDetectableEffect",
           :filters => :"Array<MetricsFilter>",
-          :error_correction => :"ErrorCorrectionType"
+          :error_correction => :"ErrorCorrectionType",
+          :method => :"AnalysisMethod",
+          :primary_metric => :"PrimaryMetric"
         }
       end
 
@@ -77,6 +85,14 @@ module Algolia
         if attributes.key?(:error_correction)
           self.error_correction = attributes[:error_correction]
         end
+
+        if attributes.key?(:method)
+          self.method = attributes[:method]
+        end
+
+        if attributes.key?(:primary_metric)
+          self.primary_metric = attributes[:primary_metric]
+        end
       end
 
       # Checks equality by comparing each attribute.
@@ -86,7 +102,9 @@ module Algolia
         self.class == other.class &&
           minimum_detectable_effect == other.minimum_detectable_effect &&
           filters == other.filters &&
-          error_correction == other.error_correction
+          error_correction == other.error_correction &&
+          method == other.method &&
+          primary_metric == other.primary_metric
       end
 
       # @see the `==` method
@@ -98,7 +116,7 @@ module Algolia
       # Calculates hash code according to all attributes.
       # @return [Integer] Hash code
       def hash
-        [minimum_detectable_effect, filters, error_correction].hash
+        [minimum_detectable_effect, filters, error_correction, method, primary_metric].hash
       end
 
       # Builds the object from hash