Generate the async chunk upload retry runtime

AsyncUploader's handwritten _do_request/_retry_or_cry recursion delegates
to the generated async upload_chunk_with_retry, the same walked per-chunk
retry procedure as the sync runtime with await at the patch and sleep
effects. The retry decision helpers stay imported from the sync modules,
and the legacy _retry_limit/_retry_delay_seconds/_should_retry helpers
leave baseuploader with their last consumer.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: kvz

tusclient/async_upload_chunks_generated.py

@@ -0,0 +1,65 @@
+# Code generated from Transloadit API2 TUS protocol contracts; DO NOT EDIT.
+# If it looks wrong, please report the issue instead of editing this file by hand;
+# the source fix belongs in the protocol contract generator so all TUS clients stay in sync.
+
+import asyncio
+
+from tusclient.abort_generated import next_retry_attempt
+from tusclient.exceptions import TusCommunicationError, TusUploadFailed
+from tusclient.upload_chunks_generated import (
+    effective_retry_attempt,
+    should_schedule_upload_retry,
+)
+
+
+async def upload_chunk_with_retry(
+    uploader,
+    perform_patch_request,
+    retry_delays,
+    on_should_retry=None,
+):
+    uploader._retried = 0
+    offset_before_retry = uploader.offset
+    start_offset = uploader.offset
+
+    if not uploader.upload_length_deferred:
+        uploader.notify_progress(start_offset)
+
+    while True:
+        error = None
+        try:
+            await perform_patch_request()
+        except TusUploadFailed as patch_error:
+            error = patch_error
+        if error is None:
+            if uploader.upload_length_deferred:
+                uploader.notify_progress(start_offset)
+            uploader.notify_progress(uploader.offset)
+            uploader.notify_chunk_complete(uploader.offset - start_offset, uploader.offset)
+            return
+
+        while error is not None:
+            effective_attempt = effective_retry_attempt(
+                uploader._retried,
+                uploader.offset,
+                offset_before_retry,
+            )
+            if not should_schedule_upload_retry(
+                on_should_retry,
+                error,
+                effective_attempt,
+                retry_delays,
+            ):
+                raise error
+
+            delay_ms = retry_delays[effective_attempt]
+            if delay_ms > 0:
+                await asyncio.sleep(delay_ms / 1000)
+            uploader._retried = next_retry_attempt(effective_attempt)
+            offset_before_retry = uploader.offset
+            error = None
+            try:
+                uploader.offset = uploader.get_offset()
+            except TusCommunicationError as sync_error:
+                error = sync_error
+            continue

tusclient/uploader/baseuploader.py

@@ -256,12 +256,6 @@ def request_method_input_options(self):
             "override_patch_method": self.override_patch_method,
         }
 
-    def _retry_limit(self):
-        if self.retry_delays is not None:
-            return len(self.retry_delays)
-
-        return self.retries
-
     def _upload_retry_delays_ms(self):
         """The retry budget as the delays-indexed-by-attempt list (in milliseconds).
 
@@ -274,18 +268,6 @@ def _upload_retry_delays_ms(self):
 
         return [self.retry_delay * 1000] * self.retries
 
-    def _retry_delay_seconds(self, retry_attempt):
-        if self.retry_delays is not None:
-            return self.retry_delays[retry_attempt] / 1000
-
-        return self.retry_delay
-
-    def _should_retry(self, error, retry_attempt):
-        if self.on_should_retry is None:
-            return True
-
-        return bool(self.on_should_retry(error, retry_attempt))
-
     def run_before_request(self, method, url, headers):
         if self.client is not None:
             self.client._set_current_uploader(self)

tusclient/uploader/uploader.py

@@ -8,6 +8,9 @@
 
 from tusclient.uploader.baseuploader import BaseUploader
 
+from tusclient.async_upload_chunks_generated import (
+    upload_chunk_with_retry as async_upload_chunk_with_retry,
+)
 from tusclient.detailed_error import (
     create_upload_request_error,
     create_upload_response_error,
@@ -396,26 +399,18 @@ async def upload_chunk(self):
         """
         Upload chunk of file.
         """
-        self._retried = 0
-
         # Ensure that we have a URL, as this is behavior we allowed previously.
         # See https://github.com/tus/tus-py-client/issues/82.
         if not self.url:
             self.set_url(await self.create_url())
             self.offset = 0
 
-        previous_offset = self.offset
-        if not self.upload_length_deferred:
-            self.notify_progress(previous_offset)
-        await self._do_request()
-        self.offset = int(self.request.response_headers.get("upload-offset"))
-        if self.upload_length_deferred and self.request.stream_eof:
-            self.file_size = self.offset
-            self.stop_at = self.offset
-        if self.upload_length_deferred:
-            self.notify_progress(previous_offset)
-        self.notify_progress(self.offset)
-        self.notify_chunk_complete(self.offset - previous_offset, self.offset)
+        await async_upload_chunk_with_retry(
+            self,
+            self._perform_patch_request,
+            self._upload_retry_delays_ms(),
+            on_should_retry=self.on_should_retry,
+        )
         self.remove_url_on_success()
 
     async def create_url(self):
@@ -459,30 +454,16 @@ async def create_url(self):
                 raise TusUploadAborted()
             raise TusCommunicationError(error)
 
-    async def _do_request(self):
+    async def _perform_patch_request(self):
+        """Send one chunk PATCH and absorb its accepted state on success.
+
+        The retry algorithm around this transport step lives in the generated
+        ``upload_chunk_with_retry`` (see tusclient/async_upload_chunks_generated.py).
+        """
         self.request = AsyncTusRequest(self)
-        try:
-            await self.request.perform()
-            _verify_upload(self.request)
-        except TusUploadFailed as error:
-            await self._retry_or_cry(error)
-
-    async def _retry_or_cry(self, error):
-        retry_attempt = self._retried
-        if self._retry_limit() <= retry_attempt:
-            raise error
-        if not self._should_retry(error, retry_attempt):
-            raise error
-
-        await asyncio.sleep(self._retry_delay_seconds(retry_attempt))
-        self._retried += 1
-        previous_offset = self.offset
-        try:
-            recovered_offset = self.get_offset()
-        except TusCommunicationError as err:
-            await self._retry_or_cry(err)
-        else:
-            if recovered_offset > previous_offset:
-                self._retried = 0
-            self.offset = recovered_offset
-            await self._do_request()
+        await self.request.perform()
+        _verify_upload(self.request)
+        self.offset = int(self.request.response_headers.get("upload-offset"))
+        if self.upload_length_deferred and self.request.stream_eof:
+            self.file_size = self.offset
+            self.stop_at = self.offset