Merge branch 'main' into fix/search-save-rules

Author: shortcuts

playground/python/app/search.py

@@ -20,14 +20,10 @@ def main():
     print("client initialized", client)
 
     try:
-        resp = client.delete_by(
-            index_name="foo", delete_by_params={"filters": "brand:name"}
-        )
-        print(resp.to_json())
+        resp = client.search_synonyms("foo")
+        print(resp)
+        client.browse_synonyms("foo", lambda _resp: print(_resp))
     finally:
         client.close()
 
         print("client closed")
-
-
-main()

templates/python/search_helpers.mustache

@@ -122,13 +122,17 @@
         self,
         index_name: str,
         aggregator: Callable[[BrowseResponse], None],
-        browse_params: BrowseParamsObject = BrowseParamsObject(),
+        browse_params: Optional[BrowseParamsObject] = None,
         request_options: Optional[Union[dict, RequestOptions]] = None,
     ) -> BrowseResponse:
         """
         Helper: Iterate on the `browse` method of the client to allow aggregating objects of an index.
         """
-        browse_params.hits_per_page = browse_params.hits_per_page or 1000
+        if browse_params is None:
+            browse_params = BrowseParamsObject(hits_per_page=1000)
+
+        if browse_params.hits_per_page is None:
+            browse_params.hits_per_page = 1000
 
         {{^isSyncClient}}async {{/isSyncClient}}def _func(_prev: Optional[BrowseResponse]) -> BrowseResponse:
             if _prev is not None and _prev.cursor is not None:
@@ -149,14 +153,18 @@
         self,
         index_name: str,
         aggregator: Callable[[SearchRulesResponse], None],
-        search_rules_params: SearchRulesParams = SearchRulesParams(hits_per_page=1000),
+        search_rules_params: Optional[SearchRulesParams] = None,
         request_options: Optional[Union[dict, RequestOptions]] = None,
     ) -> SearchRulesResponse:
         """
         Helper: Iterate on the `search_rules` method of the client to allow aggregating rules of an index.
         """
+        if search_rules_params is None:
+            search_rules_params = SearchRulesParams(hits_per_page=1000)
+
         if search_rules_params.hits_per_page is None:
             search_rules_params.hits_per_page = 1000
+
         hits_per_page = search_rules_params.hits_per_page
 
         {{^isSyncClient}}async {{/isSyncClient}}def _func(_prev: Optional[SearchRulesResponse]) -> SearchRulesResponse:
@@ -177,12 +185,17 @@
         self,
         index_name: str,
         aggregator: Callable[[SearchSynonymsResponse], None],
-        search_synonyms_params: SearchSynonymsParams = SearchSynonymsParams(hits_per_page=1000),
+        search_synonyms_params: Optional[SearchSynonymsParams] = None,
         request_options: Optional[Union[dict, RequestOptions]] = None,
     ) -> SearchSynonymsResponse:
         """
         Helper: Iterate on the `search_synonyms` method of the client to allow aggregating synonyms of an index.
         """
+        if search_synonyms_params is None:
+            search_synonyms_params = SearchSynonymsParams(
+              hits_per_page=1000,
+              page=0
+            )
         hits_per_page = 1000
         page = search_synonyms_params.page or 0
         search_synonyms_params.hits_per_page = hits_per_page
@@ -206,11 +219,13 @@
     {{^isSyncClient}}async {{/isSyncClient}}def generate_secured_api_key(
         self,
         parent_api_key: str,
-        restrictions: Optional[Union[dict, SecuredApiKeyRestrictions]] = SecuredApiKeyRestrictions(),
+        restrictions: Optional[Union[dict, SecuredApiKeyRestrictions]] = None,
     ) -> str:
         """
         Helper: Generates a secured API key based on the given `parent_api_key` and given `restrictions`.
         """
+        if restrictions is None:
+            restrictions = SecuredApiKeyRestrictions()
         restrictions_dict = {}
         if isinstance(restrictions, SecuredApiKeyRestrictions):
           restrictions_dict = restrictions.to_dict()