Merge pull request #893 from adamtheturtle/custom-wait-between-requests

Custom wait between requests

Author: adamtheturtle

src/vws/vws.py

@@ -307,13 +307,22 @@ def _wait_for_target_processed(
             sleep(seconds_between_requests)
 
     @timeout_decorator.timeout(seconds=60 * 5)
-    def wait_for_target_processed(self, target_id: str) -> None:
+    def wait_for_target_processed(
+        self,
+        target_id: str,
+        seconds_between_requests: float = 0.2,
+    ) -> None:
         """
         Wait up to five minutes (arbitrary) for a target to get past the
         processing stage.
 
         Args:
             target_id: The ID of the target to wait for.
+            seconds_between_requests: The number of seconds to wait between
+                requests made while polling the target status.
+                We wait 0.2 seconds by default, rather than less, than that to
+                decrease the number of calls made to the API, to decrease the
+                likelihood of hitting the request quota.
 
         Raises:
             ~vws.exceptions.AuthenticationFailure: The secret key is not
@@ -325,10 +334,6 @@ def wait_for_target_processed(self, target_id: str) -> None:
             ~vws.exceptions.UnknownTarget: The given target ID does not match a
                 target in the database.
         """
-        # We wait 0.2 seconds rather than less than that to decrease the
-        # number of calls made to the API, to decrease the likelihood of
-        # hitting the request quota.
-        seconds_between_requests = 0.2
         self._wait_for_target_processed(
             target_id=target_id,
             seconds_between_requests=seconds_between_requests,

tests/test_vws.py

@@ -321,6 +321,49 @@ def test_default_seconds_between_requests(
             )
             assert report['request_usage'] == expected_requests
 
+    def test_custom_seconds_between_requests(
+        self,
+        high_quality_image: io.BytesIO,
+    ) -> None:
+        """
+        It is possible to customize the time waited between polling requests.
+        """
+        with MockVWS(processing_time_seconds=0.5) as mock:
+            database = VuforiaDatabase()
+            mock.add_database(database=database)
+            client = VWS(
+                server_access_key=database.server_access_key.decode(),
+                server_secret_key=database.server_secret_key.decode(),
+            )
+
+            target_id = client.add_target(
+                name='x',
+                width=1,
+                image=high_quality_image,
+            )
+
+            client.wait_for_target_processed(
+                target_id=target_id,
+                seconds_between_requests=0.3,
+            )
+            report = client.get_database_summary_report()
+            expected_requests = (
+                # Add target request
+                1 +
+                # Database summary request
+                1 +
+                # Initial request
+                1 +
+                # Request after 0.3 seconds - not processed
+                # This assumes that there is less than 0.2 seconds taken
+                # between the start of the target processing and the start of
+                # waiting for the target to be processed.
+                1 +
+                # Request after 0.6 seconds - processed
+                1
+            )
+            assert report['request_usage'] == expected_requests
+
 
 class TestGetDuplicateTargets:
     """