use _build_retry_error as default param

Author: daniel-sanche

google/api_core/retry/retry_base.py

@@ -176,9 +176,10 @@ def _retry_error_helper(
     predicate_fn: Callable[[Exception], bool],
     on_error_fn: Callable[[Exception], None] | None,
     exc_factory_fn: Callable[
-        [list[Exception], RetryFailureReason],
+        [list[Exception], RetryFailureReason, float | None],
         tuple[Exception, Exception | None],
     ],
+    original_timeout: float | None,
 ):
     """
     Shared logic for handling an error for all retry implementations
@@ -190,17 +191,20 @@ def _retry_error_helper(
     Args:
        - exc: the exception that was raised
        - deadline: the deadline for the retry, calculated as a diff from time.monotonic()
-       - next_sleep: the calculated next sleep interval
+       - next_sleep: the next sleep interval
        - error_list: the list of exceptions that have been raised so far
-       - predicate_fn: the predicate that was used to determine if the exception should be retried
-       - on_error_fn: the callback that was called when the exception was raised
-       - exc_factory_fn: the callback that was called to build the exception to be raised on terminal failure
+       - predicate_fn: predicate used to determine if the exception should be retried
+       - on_error_fn: callback to execute when a retryable error occurs
+       - exc_factory_fn: callback used to build the exception to be raised on terminal failure
+       - original_timeout_val: the original timeout value for the retry (in seconds),
+           to be passed to the exception factory for building an error message
     """
     error_list.append(exc)
     if not predicate_fn(exc):
         final_exc, source_exc = exc_factory_fn(
             error_list,
             RetryFailureReason.NON_RETRYABLE_ERROR,
+            original_timeout,
         )
         raise final_exc from source_exc
     if on_error_fn is not None:
@@ -209,6 +213,7 @@ def _retry_error_helper(
         final_exc, source_exc = exc_factory_fn(
             error_list,
             RetryFailureReason.TIMEOUT,
+            original_timeout,
         )
         raise final_exc from source_exc
     _LOGGER.debug(

google/api_core/retry/retry_streaming.py

@@ -55,12 +55,10 @@ def retry_target_stream(
     sleep_generator: Iterable[float],
     timeout: Optional[float] = None,
     on_error: Optional[Callable[[Exception], None]] = None,
-    exception_factory: Optional[
-        Callable[
-            [List[Exception], RetryFailureReason, Optional[float]],
-            Tuple[Exception, Optional[Exception]],
-        ]
-    ] = None,
+    exception_factory: Callable[
+        [List[Exception], RetryFailureReason, Optional[float]],
+        Tuple[Exception, Optional[Exception]],
+    ] = _build_retry_error,
     init_args: _P.args = (),
     init_kwargs: _P.kwargs = {},
     **kwargs,
@@ -88,9 +86,8 @@ def retry_target_stream(
             It takes a list of all exceptions encountered, a retry.RetryFailureReason
             enum indicating the failure cause, and the original timeout value
             as arguments. It should return a tuple of the exception to be raised,
-            along with the cause exception if any.
-            If not provided, a default implementation will raise a RetryError
-            on timeout, or the last exception encountered otherwise.
+            along with the cause exception if any. The default implementation will raise
+            a RetryError on timeout, or the last exception encountered otherwise.
         init_args: Positional arguments to pass to the target function.
         init_kwargs: Keyword arguments to pass to the target function.
 
@@ -110,10 +107,6 @@ def retry_target_stream(
         time.monotonic() + timeout if timeout is not None else None
     )
     error_list: list[Exception] = []
-    # make a partial with timeout applied
-    exc_factory = lambda e, t: (exception_factory or _build_retry_error)(  # noqa: E731
-        e, t, timeout
-    )
 
     for sleep in sleep_generator:
         # Start a new retry loop
@@ -129,7 +122,7 @@ def retry_target_stream(
         except Exception as exc:
             # defer to shared logic for handling errors
             _retry_error_helper(
-                exc, deadline, sleep, error_list, predicate, on_error, exc_factory
+                exc, deadline, sleep, error_list, predicate, on_error, exception_factory, timeout
             )
             # if exception not raised, sleep before next attempt
             time.sleep(sleep)

google/api_core/retry/retry_streaming_async.py

@@ -61,8 +61,7 @@ async def retry_target_stream(
     exception_factory: Callable[
         [list[Exception], RetryFailureReason, float | None],
         tuple[Exception, Exception | None],
-    ]
-    | None = None,
+    ] = _build_retry_error,
     init_args: _P.args = (),
     init_kwargs: _P.kwargs = {},
     **kwargs,
@@ -90,9 +89,8 @@ async def retry_target_stream(
             It takes a list of all exceptions encountered, a retry.RetryFailureReason
             enum indicating the failure cause, and the original timeout value
             as arguments. It should return a tuple of the exception to be raised,
-            along with the cause exception if any.
-            If not provided, a default implementation will raise a RetryError
-            on timeout, or the last exception encountered otherwise.
+            along with the cause exception if any. The default implementation will raise
+            a RetryError on timeout, or the last exception encountered otherwise.
         init_args: Positional arguments to pass to the target function.
         init_kwargs: Keyword arguments to pass to the target function.
 
@@ -111,10 +109,6 @@ async def retry_target_stream(
     deadline = time.monotonic() + timeout if timeout else None
     # keep track of retryable exceptions we encounter to pass in to exception_factory
     error_list: list[Exception] = []
-    # make a partial with timeout applied
-    exc_factory = lambda e, t: (exception_factory or _build_retry_error)(  # noqa: E731
-        e, t, timeout
-    )
     target_is_generator: bool | None = None
 
     for sleep in sleep_generator:
@@ -181,7 +175,7 @@ async def retry_target_stream(
         except Exception as exc:
             # defer to shared logic for handling errors
             _retry_error_helper(
-                exc, deadline, sleep, error_list, predicate, on_error, exc_factory
+                exc, deadline, sleep, error_list, predicate, on_error, exception_factory, timeout
             )
             # if exception not raised, sleep before next attempt
             await asyncio.sleep(sleep)

google/api_core/retry/retry_unary.py

@@ -91,8 +91,7 @@ def retry_target(
     exception_factory: Callable[
         [list[Exception], RetryFailureReason, float | None],
         tuple[Exception, Exception | None],
-    ]
-    | None = None,
+    ] = _build_retry_error,
     **kwargs,
 ):
     """Call a function and retry if it fails.
@@ -117,9 +116,8 @@ def retry_target(
             It takes a list of all exceptions encountered, a retry.RetryFailureReason
             enum indicating the failure cause, and the original timeout value
             as arguments. It should return a tuple of the exception to be raised,
-            along with the cause exception if any.
-            If not provided, a default implementation will raise a RetryError
-            on timeout, or the last exception encountered otherwise.
+            along with the cause exception if any. The default implementation will raise
+            a RetryError on timeout, or the last exception encountered otherwise.
         deadline (float): DEPRECATED: use ``timeout`` instead. For backward
             compatibility, if specified it will override ``timeout`` parameter.
 
@@ -138,10 +136,6 @@ def retry_target(
 
     deadline = time.monotonic() + timeout if timeout is not None else None
     error_list: list[Exception] = []
-    # make a partial with timeout applied
-    exc_factory = lambda e, t: (exception_factory or _build_retry_error)(  # noqa: E731
-        e, t, timeout
-    )
 
     for sleep in sleep_generator:
         try:
@@ -155,7 +149,7 @@ def retry_target(
         except Exception as exc:
             # defer to shared logic for handling errors
             _retry_error_helper(
-                exc, deadline, sleep, error_list, predicate, on_error, exc_factory
+                exc, deadline, sleep, error_list, predicate, on_error, exception_factory, timeout
             )
             # if exception not raised, sleep before next attempt
             time.sleep(sleep)

google/api_core/retry/retry_unary_async.py

@@ -101,8 +101,7 @@ async def retry_target(
     exception_factory: Callable[
         [list[Exception], RetryFailureReason, float | None],
         tuple[Exception, Exception | None],
-    ]
-    | None = None,
+    ] = _build_retry_error,
     **kwargs,
 ):
     """Await a coroutine and retry if it fails.
@@ -127,9 +126,8 @@ async def retry_target(
             It takes a list of all exceptions encountered, a retry.RetryFailureReason
             enum indicating the failure cause, and the original timeout value
             as arguments. It should return a tuple of the exception to be raised,
-            along with the cause exception if any.
-            If not provided, a default implementation will raise a RetryError
-            on timeout, or the last exception encountered otherwise.
+            along with the cause exception if any. The default implementation will raise
+            a RetryError on timeout, or the last exception encountered otherwise.
         deadline (float): DEPRECATED use ``timeout`` instead. For backward
             compatibility, if set it will override the ``timeout`` parameter.
 
@@ -148,10 +146,6 @@ async def retry_target(
 
     deadline = time.monotonic() + timeout if timeout is not None else None
     error_list: list[Exception] = []
-    # make a partial with timeout applied
-    exc_factory = lambda e, t: (exception_factory or _build_retry_error)(  # noqa: E731
-        e, t, timeout
-    )
 
     for sleep in sleep_generator:
         try:
@@ -161,7 +155,7 @@ async def retry_target(
         except Exception as exc:
             # defer to shared logic for handling errors
             _retry_error_helper(
-                exc, deadline, sleep, error_list, predicate, on_error, exc_factory
+                exc, deadline, sleep, error_list, predicate, on_error, exception_factory, timeout
             )
             # if exception not raised, sleep before next attempt
             await asyncio.sleep(sleep)