Merge branch 'main' into fix/specs-ingestion-custom-timeout-endpoint

Author: shortcuts

clients/algoliasearch-client-python/algoliasearch/search/client.py

@@ -354,6 +354,9 @@ async def browse_objects(
         """
         Helper: Iterate on the `browse` method of the client to allow aggregating objects of an index.
         """
+        if isinstance(browse_params, dict):
+            browse_params = BrowseParamsObject().from_dict(browse_params)
+
         if browse_params is None:
             browse_params = BrowseParamsObject(hits_per_page=1000)
 
@@ -385,6 +388,9 @@ async def browse_rules(
         """
         Helper: Iterate on the `search_rules` method of the client to allow aggregating rules of an index.
         """
+        if isinstance(search_rules_params, dict):
+            search_rules_params = SearchRulesParams().from_dict(search_rules_params)
+
         if search_rules_params is None:
             search_rules_params = SearchRulesParams(hits_per_page=1000)
 
@@ -418,6 +424,11 @@ async def browse_synonyms(
         """
         Helper: Iterate on the `search_synonyms` method of the client to allow aggregating synonyms of an index.
         """
+        if isinstance(search_synonyms_params, dict):
+            search_synonyms_params = SearchSynonymsParams().from_dict(
+                search_synonyms_params
+            )
+
         if search_synonyms_params is None:
             search_synonyms_params = SearchSynonymsParams(hits_per_page=1000, page=0)
         hits_per_page = 1000
@@ -453,6 +464,7 @@ async def generate_secured_api_key(
         """
         if restrictions is None:
             restrictions = SecuredApiKeyRestrictions()
+
         restrictions_dict = {}
         if isinstance(restrictions, SecuredApiKeyRestrictions):
             restrictions_dict = restrictions.to_dict()
@@ -5384,6 +5396,9 @@ def browse_objects(
         """
         Helper: Iterate on the `browse` method of the client to allow aggregating objects of an index.
         """
+        if isinstance(browse_params, dict):
+            browse_params = BrowseParamsObject().from_dict(browse_params)
+
         if browse_params is None:
             browse_params = BrowseParamsObject(hits_per_page=1000)
 
@@ -5415,6 +5430,9 @@ def browse_rules(
         """
         Helper: Iterate on the `search_rules` method of the client to allow aggregating rules of an index.
         """
+        if isinstance(search_rules_params, dict):
+            search_rules_params = SearchRulesParams().from_dict(search_rules_params)
+
         if search_rules_params is None:
             search_rules_params = SearchRulesParams(hits_per_page=1000)
 
@@ -5448,6 +5466,11 @@ def browse_synonyms(
         """
         Helper: Iterate on the `search_synonyms` method of the client to allow aggregating synonyms of an index.
         """
+        if isinstance(search_synonyms_params, dict):
+            search_synonyms_params = SearchSynonymsParams().from_dict(
+                search_synonyms_params
+            )
+
         if search_synonyms_params is None:
             search_synonyms_params = SearchSynonymsParams(hits_per_page=1000, page=0)
         hits_per_page = 1000
@@ -5481,6 +5504,7 @@ def generate_secured_api_key(
         """
         if restrictions is None:
             restrictions = SecuredApiKeyRestrictions()
+
         restrictions_dict = {}
         if isinstance(restrictions, SecuredApiKeyRestrictions):
             restrictions_dict = restrictions.to_dict()

clients/algoliasearch-client-ruby/lib/algolia/api/search_client.rb

@@ -3150,19 +3150,21 @@ def wait_for_app_task(
     def wait_for_api_key(
       key,
       operation,
-      api_key = {},
+      api_key = Search::ApiKey.new,
       max_retries = 50,
       timeout = -> (retry_count) { [retry_count * 200, 5000].min },
       request_options = {}
     )
+      api_key = api_client.object_to_hash(api_key)
+
       retries = 0
       if operation == "update"
         raise ArgumentError, "`api_key` is required when waiting for an `update` operation." if api_key.nil?
         while retries < max_retries
           updated_key = get_api_key(key, request_options)
           updated_key_hash = updated_key.to_hash
           equals = true
-          api_key.to_hash.each do |k, v|
+          api_key.each do |k, v|
             equals &&= updated_key_hash[k] == v
           end
 
@@ -3201,7 +3203,9 @@ def wait_for_api_key(
     # @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)
-      browse_params.hits_per_page ||= 1000
+      browse_params = api_client.object_to_hash(browse_params)
+
+      browse_params[:hitsPerPage] = 1000 unless browse_params.key?(:hitsPerPage)
 
       hits = []
       loop do
@@ -3214,8 +3218,8 @@ def browse_objects(index_name, browse_params = Search::BrowseParamsObject.new, r
           hits.concat(res.hits)
         end
 
-        browse_params.cursor = res.cursor
-        break if browse_params.cursor.nil?
+        browse_params[:cursor] = res.cursor
+        break if browse_params[:cursor].nil?
       end
 
       hits unless block_given?
@@ -3227,12 +3231,11 @@ def browse_objects(index_name, browse_params = Search::BrowseParamsObject.new, r
     # @param search_rules_params [SearchRulesParams] the parameters to send along with the query, they will be forwarded to the `searchRules` method.
     # @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(hits_per_page: 1000, page: 0),
-      request_options = {},
-      &block
-    )
+    def browse_rules(index_name, search_rules_params = Search::SearchRulesParams.new, request_options = {}, &block)
+      search_rules_params = api_client.object_to_hash(search_rules_params)
+
+      search_rules_params[:hitsPerPage] = 1000 unless search_rules_params.key?(:hitsPerPage)
+
       rules = []
       loop do
         res = search_rules(index_name, search_rules_params, request_options)
@@ -3244,8 +3247,8 @@ def browse_rules(
           rules.concat(res.hits)
         end
 
-        search_rules_params.page += 1
-        break if res.hits.length < search_rules_params.hits_per_page
+        search_rules_params[:page] += 1
+        break if res.hits.length < search_rules_params[:hitsPerPage]
       end
 
       rules unless block_given?
@@ -3259,10 +3262,14 @@ def browse_rules(
     # @param block [Proc] the block to execute on each synonym of the index.
     def browse_synonyms(
       index_name,
-      search_synonyms_params = Search::SearchSynonymsParams.new(hits_per_page: 1000, page: 0),
+      search_synonyms_params = Search::SearchSynonymsParams.new,
       request_options = {},
       &block
     )
+      search_synonyms_params = api_client.object_to_hash(search_synonyms_params)
+
+      search_synonyms_params[:hitsPerPage] = 1000 unless search_synonyms_params.key?(:hitsPerPage)
+
       synonyms = []
       loop do
         res = search_synonyms(index_name, search_synonyms_params, request_options)
@@ -3274,8 +3281,8 @@ def browse_synonyms(
           synonyms.concat(res.hits)
         end
 
-        search_synonyms_params.page += 1
-        break if res.hits.length < search_synonyms_params.hits_per_page
+        search_synonyms_params[:page] += 1
+        break if res.hits.length < search_synonyms_params[:hitsPerPage]
       end
 
       synonyms unless block_given?
@@ -3543,6 +3550,5 @@ def index_exists?(index_name)
 
       true
     end
-
   end
 end

playground/ruby/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ../../clients/algoliasearch-client-ruby
   specs:
-    algolia (3.10.0)
+    algolia (3.10.1)
       base64 (>= 0.2.0, < 1)
       faraday (>= 1.0.1, < 3.0)
       faraday-net_http_persistent (>= 0.15, < 3)

playground/ruby/search.rb

@@ -6,7 +6,7 @@
 client = Algolia::SearchClient.create(ENV['ALGOLIA_APPLICATION_ID'], ENV['ALGOLIA_ADMIN_KEY'])
 # set a custom user agent
 client.add_user_agent_segment('Algolia for rails', "test")
-res = client.search_single_index('contacts', Algolia::Search::SearchParamsObject.new(query: 'Jimmie'))
+res = client.browse_objects('qigbuery-RECORDS')
 puts res
 
 =begin

templates/python/search_helpers.mustache

@@ -128,6 +128,9 @@
         """
         Helper: Iterate on the `browse` method of the client to allow aggregating objects of an index.
         """
+        if isinstance(browse_params, dict):
+            browse_params = BrowseParamsObject().from_dict(browse_params)
+
         if browse_params is None:
             browse_params = BrowseParamsObject(hits_per_page=1000)
 
@@ -159,6 +162,9 @@
         """
         Helper: Iterate on the `search_rules` method of the client to allow aggregating rules of an index.
         """
+        if isinstance(search_rules_params, dict):
+            search_rules_params = SearchRulesParams().from_dict(search_rules_params)
+
         if search_rules_params is None:
             search_rules_params = SearchRulesParams(hits_per_page=1000)
 
@@ -191,6 +197,9 @@
         """
         Helper: Iterate on the `search_synonyms` method of the client to allow aggregating synonyms of an index.
         """
+        if isinstance(search_synonyms_params, dict):
+            search_synonyms_params = SearchSynonymsParams().from_dict(search_synonyms_params)
+
         if search_synonyms_params is None:
             search_synonyms_params = SearchSynonymsParams(
               hits_per_page=1000,
@@ -226,6 +235,7 @@
         """
         if restrictions is None:
             restrictions = SecuredApiKeyRestrictions()
+
         restrictions_dict = {}
         if isinstance(restrictions, SecuredApiKeyRestrictions):
           restrictions_dict = restrictions.to_dict()

templates/ruby/search_helpers.mustache

@@ -48,15 +48,17 @@ end
 # @param timeout [Proc] the function to decide how long to wait between retries.
 # @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(key, operation, api_key = {}, max_retries = 50, timeout = -> (retry_count) { [retry_count * 200, 5000].min }, request_options = {})
+def wait_for_api_key(key, operation, api_key = Search::ApiKey.new, max_retries = 50, timeout = -> (retry_count) { [retry_count * 200, 5000].min }, request_options = {})
+  api_key = api_client.object_to_hash(api_key)
+
   retries = 0
   if operation == 'update'
     raise ArgumentError, '`api_key` is required when waiting for an `update` operation.' if api_key.nil?
     while retries < max_retries
       updated_key = get_api_key(key, request_options)
       updated_key_hash = updated_key.to_hash
       equals = true
-      api_key.to_hash.each do |k, v|
+      api_key.each do |k, v|
         equals &&= updated_key_hash[k] == v
       end
 
@@ -95,7 +97,9 @@ end
 # @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)
-  browse_params.hits_per_page ||= 1000
+  browse_params = api_client.object_to_hash(browse_params)
+
+  browse_params[:hitsPerPage] = 1000 unless browse_params.key?(:hitsPerPage)
 
   hits = []
   loop do
@@ -107,8 +111,9 @@ def browse_objects(index_name, browse_params = Search::BrowseParamsObject.new, r
     else
       hits.concat(res.hits)
     end
-    browse_params.cursor = res.cursor
-    break if browse_params.cursor.nil?
+
+    browse_params[:cursor] = res.cursor
+    break if browse_params[:cursor].nil?
   end
 
   hits unless block_given?
@@ -120,7 +125,11 @@ end
 # @param search_rules_params [SearchRulesParams] the parameters to send along with the query, they will be forwarded to the `searchRules` method.
 # @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(hits_per_page: 1000, page: 0), request_options = {}, &block)
+def browse_rules(index_name, search_rules_params = Search::SearchRulesParams.new, request_options = {}, &block)
+  search_rules_params = api_client.object_to_hash(search_rules_params)
+
+  search_rules_params[:hitsPerPage] = 1000 unless search_rules_params.key?(:hitsPerPage)
+
   rules = []
   loop do
     res = search_rules(index_name, search_rules_params, request_options)
@@ -131,8 +140,8 @@ def browse_rules(index_name, search_rules_params = Search::SearchRulesParams.new
     else
       rules.concat(res.hits)
     end
-    search_rules_params.page += 1
-    break if res.hits.length < search_rules_params.hits_per_page
+    search_rules_params[:page] += 1
+    break if res.hits.length < search_rules_params[:hitsPerPage]
   end
 
   rules unless block_given?
@@ -144,7 +153,11 @@ end
 # @param search_synonyms_params [SearchSynonymsParams] the parameters to send along with the query, they will be forwarded to the `searchSynonyms` method.
 # @param request_options [Hash] the requestOptions to send along with the query, they will be forwarded to the `searchSynonyms` method.
 # @param block [Proc] the block to execute on each synonym of the index.
-def browse_synonyms(index_name, search_synonyms_params = Search::SearchSynonymsParams.new(hits_per_page: 1000, page: 0), request_options = {}, &block)
+def browse_synonyms(index_name, search_synonyms_params = Search::SearchSynonymsParams.new, request_options = {}, &block)
+  search_synonyms_params = api_client.object_to_hash(search_synonyms_params)
+
+  search_synonyms_params[:hitsPerPage] = 1000 unless search_synonyms_params.key?(:hitsPerPage)
+
   synonyms = []
   loop do
     res = search_synonyms(index_name, search_synonyms_params, request_options)
@@ -155,8 +168,8 @@ def browse_synonyms(index_name, search_synonyms_params = Search::SearchSynonymsP
     else
       synonyms.concat(res.hits)
     end
-    search_synonyms_params.page += 1
-    break if res.hits.length < search_synonyms_params.hits_per_page
+    search_synonyms_params[:page] += 1
+    break if res.hits.length < search_synonyms_params[:hitsPerPage]
   end
 
   synonyms unless block_given?
@@ -405,4 +418,4 @@ def index_exists?(index_name)
   end
 
   true
-end
+end