feat: Add requestslimit_timeout class init variable

Author: Goblenus

readme.md

@@ -40,6 +40,14 @@ wallhaven_api = wallhavenapi.WallhavenApiV1(api_key="some_api_key")
 
 ## Methods
 
+### WallhavenApiV1
+
+* api_key {String} - your **[Wallhaven](https://wallhaven.cc)** [api key](https://wallhaven.cc/settings/account)
+* verify_connection {Bool} - check ssl cert
+* base_url {String} - **[Wallhaven](https://wallhaven.cc)** base api url
+* timeout {Tuple(Int, Int)} - http request timeout
+* requestslimit_timeout {Tuple(Int, Int)} - try to handle 429 http error. The first Int - how many times to do request, the second - delay (in seconds) between requests.
+
 ### WallhavenApiV1.search - Accessing Wallpaper information
 
 * q {String} - query (used to filter by user, tags, ids and [so on...](https://wallhaven.cc/help/api#search))

tests.py

@@ -5,50 +5,33 @@
 import time
 
 
-def request_limit_decorator(test_method):
-    def wrapper(self, *args, **kwargs):
-        for _ in range(20):
-            try:
-                result = test_method(self, *args, **kwargs)
-                break
-            except RequestsLimitError:
-                time.sleep(5)
-        else:
-            raise RequestsLimitError()
-                
-        return result
-    return wrapper
-
-
 class TestWallhavenApiV1(unittest.TestCase):
     @classmethod
     def setUpClass(self):
         self.wallhaven_api = WallhavenApiV1(api_key=os.getenv('APIKEY', None), verify_connection=False, 
-                                            base_url="http://wallhaven.cc/api/v1")
+                                            base_url="http://wallhaven.cc/api/v1", 
+                                            requestslimit_timeout=(15, 5))
 
     def test_search(self):
         search_data = self.wallhaven_api.search()
 
         self.assertIn("data", search_data)
         self.assertIn("meta", search_data)
 
-    @request_limit_decorator
     def test_search_categories(self):
         for category in list(Category):
             search_data = self.wallhaven_api.search(categories=category)
 
             for wallpaper_data in search_data["data"]:
                 self.assertEqual(category.value, wallpaper_data["category"])
 
-    @request_limit_decorator
     def test_search_purities(self):
         for purity in list(Purity):
             search_data = self.wallhaven_api.search(purities=purity)
 
             for wallpaper_data in search_data["data"]:
                 self.assertEqual(purity.value, wallpaper_data["purity"])
 
-    @request_limit_decorator
     def test_search_sorting(self):
         for sorting_method in list(Sorting):
             search_data = self.wallhaven_api.search(sorting=sorting_method)
@@ -66,15 +49,12 @@ def parse_datetime(datetime_string):
             self.assertGreaterEqual(datetime_1, datetime_2) \
             if order == Order.desc else self.assertLessEqual(datetime_1, datetime_2)
 
-    @request_limit_decorator
     def test_search_sorting_dated_added_asc(self):
         self.search_sorting_dated_added(Order.asc)
 
-    @request_limit_decorator
     def test_search_sorting_dated_added_desc(self):
         self.search_sorting_dated_added(Order.desc)
 
-    @request_limit_decorator
     def search_sorting_views(self, order):
         search_data = self.wallhaven_api.search(sorting=Sorting.views, order=order)
         for i in range(len(search_data["data"]) - 1):
@@ -83,12 +63,10 @@ def search_sorting_views(self, order):
             self.assertGreaterEqual(views_1, views_2) \
             if order == Order.desc else self.assertLessEqual(views_1, views_2)
 
-    @request_limit_decorator
     @unittest.skip("May content unsorted results. Need help")
     def test_search_sorting_views_asc(self):
         self.search_sorting_views(Order.asc)
 
-    @request_limit_decorator
     @unittest.skip("May content unsorted results. Need help")
     def test_search_sorting_views_desc(self):
         self.search_sorting_views(Order.desc)
@@ -101,17 +79,14 @@ def search_sorting_favorites(self, order):
             self.assertGreaterEqual(favorites_1, favorites_2) \
             if order == Order.desc else self.assertLessEqual(favorites_1, favorites_2)
 
-    @request_limit_decorator
     @unittest.skip("May content unsorted results. Need help")
     def test_search_sorting_favorites_asc(self):
         self.search_sorting_favorites(Order.asc)
 
-    @request_limit_decorator
     @unittest.skip("May content unsorted results. Need help")
     def test_search_sorting_favorites_desc(self):
         self.search_sorting_favorites(Order.desc)
 
-    @request_limit_decorator
     @unittest.skip("May content unsorted results. Need help")
     def test_search_top_range(self):
         for top_range in list(TopRange):
@@ -132,35 +107,30 @@ def test_search_top_range(self):
 
                 self.assertGreaterEqual(created_at, datetime.datetime.now() - timedelta)
 
-    @request_limit_decorator
     def test_search_atleast(self):
         search_data = self.wallhaven_api.search(atleast=(1920, 1080))
         for wallpaper in search_data["data"]:
             self.assertGreaterEqual(int(wallpaper["dimension_x"]), 1920)
             self.assertGreaterEqual(int(wallpaper["dimension_y"]), 1080)
 
-    @request_limit_decorator
     def test_search_resolutions(self):
         search_data = self.wallhaven_api.search(resolutions=(1920, 1080))
         for wallpaper in search_data["data"]:
             self.assertEqual(int(wallpaper["dimension_x"]), 1920)
             self.assertEqual(int(wallpaper["dimension_y"]), 1080)
 
-    @request_limit_decorator
     def test_search_ratios(self):
         search_data = self.wallhaven_api.search(ratios=(16, 10))
         for wallpaper in search_data["data"]:
             self.assertEqual(float(wallpaper["ratio"]), 1.6)
 
-    @request_limit_decorator
     def test_search_colors(self):
         for color in list(Color):
             search_data = self.wallhaven_api.search(colors=color)
             for wallpaper in search_data["data"]:
                 self.assertIn("colors", wallpaper)
                 self.assertIn("#{}".format(color.value), wallpaper["colors"])
 
-    @request_limit_decorator
     def test_search_page(self):
         search_data = self.wallhaven_api.search()
 
@@ -174,7 +144,6 @@ def test_search_page(self):
             self.assertIn("current_page", search_data["meta"])
             self.assertEqual(2, int(search_data["meta"]["current_page"]))
 
-    @request_limit_decorator
     def test_wallpaper(self):
         search_data = self.wallhaven_api.search()
 
@@ -187,7 +156,6 @@ def test_wallpaper(self):
         wallpaper = self.wallhaven_api.wallpaper(search_data["data"][0]["id"])
         self.assertIn("data", wallpaper)
 
-    @request_limit_decorator
     def test_tag(self):
         search_data = self.wallhaven_api.search()
 
@@ -209,7 +177,6 @@ def test_tag(self):
 
             break
 
-    @request_limit_decorator
     def test_search_query_uploader(self):
         search_data = self.wallhaven_api.search()
 
@@ -230,7 +197,6 @@ def test_search_query_uploader(self):
 
         self.assertGreater(len(search_data["data"]), 0)
 
-    @request_limit_decorator
     def test_search_query_id(self):
         search_data = self.wallhaven_api.search()
 
@@ -252,7 +218,6 @@ def test_search_query_id(self):
             self.assertGreater(len(search_data["data"]), 0)
             break
 
-    @request_limit_decorator
     def test_search_query_like(self):
         search_data = self.wallhaven_api.search()
 
@@ -264,7 +229,6 @@ def test_search_query_like(self):
         self.assertIn("data", search_data)
         self.assertIn("meta", search_data)
 
-    @request_limit_decorator
     def test_search_query_type(self):
         for image_type in Type:
             search_data = self.wallhaven_api.search(q="type:{}".format(image_type.value))
@@ -280,13 +244,11 @@ def test_search_query_type(self):
                 else:
                     self.assertTrue(str(wallpaper["file_type"]).endswith(image_type.value))
 
-    @request_limit_decorator
     def test_settings(self):
         result = self.wallhaven_api.settings()
 
         assert result is None if self.wallhaven_api.api_key is None else result is not None
 
-    @request_limit_decorator
     def test_collections(self):
                                                 # Just a random user, who has a collection with wallpapers
         result = self.wallhaven_api.collections("ThorRagnarok")
@@ -297,7 +259,6 @@ def test_collections(self):
 
         return result
 
-    @request_limit_decorator
     def test_collection_wallpapers(self, page=None):
         collections = self.test_collections()
 
@@ -308,11 +269,9 @@ def test_collection_wallpapers(self, page=None):
         assert "meta" in collections_wallpapers
         assert len(collections_wallpapers["data"])
 
-    @request_limit_decorator
     def test_collection_wallpapers_page(self):
         self.test_collection_wallpapers(2)
 
-    @request_limit_decorator
     def test_my_collections(self):
         result = self.wallhaven_api.my_collections()
 

wallhavenapi.py

@@ -4,6 +4,7 @@
 from enum import Enum
 import random
 import string
+import time
 
 
 class Purity(Enum):
@@ -112,43 +113,50 @@ def __init__(self, wallpaper_id):
 
 class WallhavenApiV1:
     def __init__(self, api_key=None, verify_connection=True, base_url="https://wallhaven.cc/api/v1", 
-                 timeout=(2,5)):
+                 timeout=(2,5), requestslimit_timeout=None):
         self.verify_connection = verify_connection
         self.api_key = api_key
         self.base_url = base_url
         self.timeout = timeout
+        self.requestslimit_timeout = requestslimit_timeout
 
     def _request(self, to_json, **kwargs):
-        if self.api_key is not None:
-            if "params" in kwargs:
-                kwargs["params"]["apikey"] = self.api_key
-            else:
-                kwargs["params"] = {"apikey": self.api_key}
+        for i in range(self.requestslimit_timeout[0] if self.requestslimit_timeout is not None else 1):
+            if self.api_key is not None:
+                if "params" in kwargs:
+                    kwargs["params"]["apikey"] = self.api_key
+                else:
+                    kwargs["params"] = {"apikey": self.api_key}
 
-        if "timeout" not in kwargs:
-            kwargs["timeout"] = self.timeout
+            if "timeout" not in kwargs:
+                kwargs["timeout"] = self.timeout
 
-        if "verify" not in kwargs:
-            kwargs["verify"] = self.verify_connection
+            if "verify" not in kwargs:
+                kwargs["verify"] = self.verify_connection
 
-        response = requests.request(**kwargs)
+            response = requests.request(**kwargs)
 
-        if response.status_code == 429:
-            raise RequestsLimitError
+            if response.status_code == 429:
+                if self.requestslimit_timeout is None\
+                    or i == (self.requestslimit_timeout[0] - 1) if self.requestslimit_timeout is not None else 0:
+                    raise RequestsLimitError
+                
+                time.sleep(self.requestslimit_timeout[1])
+                continue
 
-        if response.status_code == 401:
-            raise ApiKeyError
+            if response.status_code == 401:
+                raise ApiKeyError
 
-        if response.status_code != 200:
-            raise UnhandledException
-
-        if to_json:
-            try:
-                return response.json()
-            except:
+            if response.status_code != 200:
                 raise UnhandledException
 
-        return response
+            if to_json:
+                try:
+                    return response.json()
+                except:
+                    raise UnhandledException
+
+            return response
 
     def _url_format(self, *args):
         url = self.base_url