Upgrade tenacity to 7.0.0

Author: sbidoul

news/tenacity.vendor.rst

@@ -1 +1 @@
-Switch from retrying to tenacity
+Upgrade tenacity to 7.0.0

src/pip/_vendor/tenacity/__init__.py

@@ -38,9 +38,9 @@
 from pip._vendor import six
 
 from pip._vendor.tenacity import _utils
-from pip._vendor.tenacity import compat as _compat
 
 # Import all built-in retry strategies for easier usage.
+from .retry import retry_base  # noqa
 from .retry import retry_all  # noqa
 from .retry import retry_always  # noqa
 from .retry import retry_any  # noqa
@@ -116,11 +116,23 @@ def retry(*dargs, **dkw):  # noqa
     if len(dargs) == 1 and callable(dargs[0]):
         return retry()(dargs[0])
     else:
+
         def wrap(f):
+            if isinstance(f, retry_base):
+                warnings.warn(
+                    (
+                        "Got retry_base instance ({cls}) as callable argument, "
+                        + "this will probably hang indefinitely (did you mean "
+                        + "retry={cls}(...)?)"
+                    ).format(cls=f.__class__.__name__)
+                )
             if iscoroutinefunction is not None and iscoroutinefunction(f):
                 r = AsyncRetrying(*dargs, **dkw)
-            elif tornado and hasattr(tornado.gen, 'is_coroutine_function') \
-                    and tornado.gen.is_coroutine_function(f):
+            elif (
+                tornado
+                and hasattr(tornado.gen, "is_coroutine_function")
+                and tornado.gen.is_coroutine_function(f)
+            ):
                 r = TornadoRetrying(*dargs, **dkw)
             else:
                 r = Retrying(*dargs, **dkw)
@@ -158,17 +170,18 @@ class BaseAction(object):
     NAME = None
 
     def __repr__(self):
-        state_str = ', '.join('%s=%r' % (field, getattr(self, field))
-                              for field in self.REPR_FIELDS)
-        return '%s(%s)' % (type(self).__name__, state_str)
+        state_str = ", ".join(
+            "%s=%r" % (field, getattr(self, field)) for field in self.REPR_FIELDS
+        )
+        return "%s(%s)" % (type(self).__name__, state_str)
 
     def __str__(self):
         return repr(self)
 
 
 class RetryAction(BaseAction):
-    REPR_FIELDS = ('sleep',)
-    NAME = 'retry'
+    REPR_FIELDS = ("sleep",)
+    NAME = "retry"
 
     def __init__(self, sleep):
         self.sleep = float(sleep)
@@ -177,6 +190,10 @@ def __init__(self, sleep):
 _unset = object()
 
 
+def _first_set(first, second):
+    return second if first is _unset else first
+
+
 class RetryError(Exception):
     """Encapsulates the last attempt instance right before giving up."""
 
@@ -214,86 +231,74 @@ def __exit__(self, exc_type, exc_value, traceback):
 class BaseRetrying(object):
     __metaclass__ = ABCMeta
 
-    def __init__(self,
-                 sleep=sleep,
-                 stop=stop_never, wait=wait_none(),
-                 retry=retry_if_exception_type(),
-                 before=before_nothing,
-                 after=after_nothing,
-                 before_sleep=None,
-                 reraise=False,
-                 retry_error_cls=RetryError,
-                 retry_error_callback=None):
+    def __init__(
+        self,
+        sleep=sleep,
+        stop=stop_never,
+        wait=wait_none(),
+        retry=retry_if_exception_type(),
+        before=before_nothing,
+        after=after_nothing,
+        before_sleep=None,
+        reraise=False,
+        retry_error_cls=RetryError,
+        retry_error_callback=None,
+    ):
         self.sleep = sleep
-        self._stop = stop
-        self._wait = wait
-        self._retry = retry
-        self._before = before
-        self._after = after
-        self._before_sleep = before_sleep
+        self.stop = stop
+        self.wait = wait
+        self.retry = retry
+        self.before = before
+        self.after = after
+        self.before_sleep = before_sleep
         self.reraise = reraise
         self._local = threading.local()
         self.retry_error_cls = retry_error_cls
-        self._retry_error_callback = retry_error_callback
+        self.retry_error_callback = retry_error_callback
 
         # This attribute was moved to RetryCallState and is deprecated on
         # Retrying objects but kept for backward compatibility.
         self.fn = None
 
-    @_utils.cached_property
-    def stop(self):
-        return _compat.stop_func_accept_retry_state(self._stop)
-
-    @_utils.cached_property
-    def wait(self):
-        return _compat.wait_func_accept_retry_state(self._wait)
-
-    @_utils.cached_property
-    def retry(self):
-        return _compat.retry_func_accept_retry_state(self._retry)
-
-    @_utils.cached_property
-    def before(self):
-        return _compat.before_func_accept_retry_state(self._before)
-
-    @_utils.cached_property
-    def after(self):
-        return _compat.after_func_accept_retry_state(self._after)
-
-    @_utils.cached_property
-    def before_sleep(self):
-        return _compat.before_sleep_func_accept_retry_state(self._before_sleep)
-
-    @_utils.cached_property
-    def retry_error_callback(self):
-        return _compat.retry_error_callback_accept_retry_state(
-            self._retry_error_callback)
-
-    def copy(self, sleep=_unset, stop=_unset, wait=_unset,
-             retry=_unset, before=_unset, after=_unset, before_sleep=_unset,
-             reraise=_unset):
+    def copy(
+        self,
+        sleep=_unset,
+        stop=_unset,
+        wait=_unset,
+        retry=_unset,
+        before=_unset,
+        after=_unset,
+        before_sleep=_unset,
+        reraise=_unset,
+        retry_error_cls=_unset,
+        retry_error_callback=_unset,
+    ):
         """Copy this object with some parameters changed if needed."""
-        if before_sleep is _unset:
-            before_sleep = self.before_sleep
         return self.__class__(
-            sleep=self.sleep if sleep is _unset else sleep,
-            stop=self.stop if stop is _unset else stop,
-            wait=self.wait if wait is _unset else wait,
-            retry=self.retry if retry is _unset else retry,
-            before=self.before if before is _unset else before,
-            after=self.after if after is _unset else after,
-            before_sleep=before_sleep,
-            reraise=self.reraise if after is _unset else reraise,
+            sleep=_first_set(sleep, self.sleep),
+            stop=_first_set(stop, self.stop),
+            wait=_first_set(wait, self.wait),
+            retry=_first_set(retry, self.retry),
+            before=_first_set(before, self.before),
+            after=_first_set(after, self.after),
+            before_sleep=_first_set(before_sleep, self.before_sleep),
+            reraise=_first_set(reraise, self.reraise),
+            retry_error_cls=_first_set(retry_error_cls, self.retry_error_cls),
+            retry_error_callback=_first_set(
+                retry_error_callback, self.retry_error_callback
+            ),
         )
 
     def __repr__(self):
         attrs = dict(
-            _utils.visible_attrs(self, attrs={'me': id(self)}),
+            _utils.visible_attrs(self, attrs={"me": id(self)}),
             __class__=self.__class__.__name__,
         )
-        return ("<%(__class__)s object at 0x%(me)x (stop=%(stop)s, "
-                "wait=%(wait)s, sleep=%(sleep)s, retry=%(retry)s, "
-                "before=%(before)s, after=%(after)s)>") % (attrs)
+        return (
+            "<%(__class__)s object at 0x%(me)x (stop=%(stop)s, "
+            "wait=%(wait)s, sleep=%(sleep)s, retry=%(retry)s, "
+            "before=%(before)s, after=%(after)s)>"
+        ) % (attrs)
 
     @property
     def statistics(self):
@@ -328,6 +333,7 @@ def wraps(self, f):
 
         :param f: A function to wraps for retrying.
         """
+
         @_utils.wraps(f)
         def wrapped_f(*args, **kw):
             return self(f, *args, **kw)
@@ -342,9 +348,9 @@ def retry_with(*args, **kwargs):
 
     def begin(self, fn):
         self.statistics.clear()
-        self.statistics['start_time'] = _utils.now()
-        self.statistics['attempt_number'] = 1
-        self.statistics['idle_for'] = 0
+        self.statistics["start_time"] = _utils.now()
+        self.statistics["attempt_number"] = 1
+        self.statistics["idle_for"] = 0
         self.fn = fn
 
     def iter(self, retry_state):  # noqa
@@ -354,16 +360,16 @@ def iter(self, retry_state):  # noqa
                 self.before(retry_state)
             return DoAttempt()
 
-        is_explicit_retry = retry_state.outcome.failed \
-            and isinstance(retry_state.outcome.exception(), TryAgain)
+        is_explicit_retry = retry_state.outcome.failed and isinstance(
+            retry_state.outcome.exception(), TryAgain
+        )
         if not (is_explicit_retry or self.retry(retry_state=retry_state)):
             return fut.result()
 
         if self.after is not None:
             self.after(retry_state=retry_state)
 
-        self.statistics['delay_since_first_attempt'] = \
-            retry_state.seconds_since_start
+        self.statistics["delay_since_first_attempt"] = retry_state.seconds_since_start
         if self.stop(retry_state=retry_state):
             if self.retry_error_callback:
                 return self.retry_error_callback(retry_state=retry_state)
@@ -378,8 +384,8 @@ def iter(self, retry_state):  # noqa
             sleep = 0.0
         retry_state.next_action = RetryAction(sleep)
         retry_state.idle_for += sleep
-        self.statistics['idle_for'] += sleep
-        self.statistics['attempt_number'] += 1
+        self.statistics["idle_for"] += sleep
+        self.statistics["attempt_number"] += 1
 
         if self.before_sleep is not None:
             self.before_sleep(retry_state=retry_state)
@@ -406,8 +412,10 @@ def __call__(self, *args, **kwargs):
 
     def call(self, *args, **kwargs):
         """Use ``__call__`` instead because this method is deprecated."""
-        warnings.warn("'call()' method is deprecated. " +
-                      "Use '__call__()' instead", DeprecationWarning)
+        warnings.warn(
+            "'call()' method is deprecated. " + "Use '__call__()' instead",
+            DeprecationWarning,
+        )
         return self.__call__(*args, **kwargs)
 
 
@@ -417,14 +425,13 @@ class Retrying(BaseRetrying):
     def __call__(self, fn, *args, **kwargs):
         self.begin(fn)
 
-        retry_state = RetryCallState(
-            retry_object=self, fn=fn, args=args, kwargs=kwargs)
+        retry_state = RetryCallState(retry_object=self, fn=fn, args=args, kwargs=kwargs)
         while True:
             do = self.iter(retry_state=retry_state)
             if isinstance(do, DoAttempt):
                 try:
                     result = fn(*args, **kwargs)
-                except BaseException:
+                except BaseException:  # noqa: B902
                     retry_state.set_exception(sys.exc_info())
                 else:
                     retry_state.set_result(result)

src/pip/_vendor/tenacity/_asyncio.py

@@ -26,24 +26,20 @@
 
 
 class AsyncRetrying(BaseRetrying):
-
-    def __init__(self,
-                 sleep=sleep,
-                 **kwargs):
+    def __init__(self, sleep=sleep, **kwargs):
         super(AsyncRetrying, self).__init__(**kwargs)
         self.sleep = sleep
 
     async def __call__(self, fn, *args, **kwargs):
         self.begin(fn)
 
-        retry_state = RetryCallState(
-            retry_object=self, fn=fn, args=args, kwargs=kwargs)
+        retry_state = RetryCallState(retry_object=self, fn=fn, args=args, kwargs=kwargs)
         while True:
             do = self.iter(retry_state=retry_state)
             if isinstance(do, DoAttempt):
                 try:
                     result = await fn(*args, **kwargs)
-                except BaseException:
+                except BaseException:  # noqa: B902
                     retry_state.set_exception(sys.exc_info())
                 else:
                     retry_state.set_result(result)

src/pip/_vendor/tenacity/_utils.py

@@ -40,12 +40,15 @@ def wraps(fn):
 
         Also, see https://github.com/benjaminp/six/issues/250.
         """
+
         def filter_hasattr(obj, attrs):
             return tuple(a for a in attrs if hasattr(obj, a))
+
         return six.wraps(
             fn,
             assigned=filter_hasattr(fn, WRAPPER_ASSIGNMENTS),
-            updated=filter_hasattr(fn, WRAPPER_UPDATES))
+            updated=filter_hasattr(fn, WRAPPER_UPDATES),
+        )
 
     def capture(fut, tb):
         # TODO(harlowja): delete this in future, since its
@@ -55,6 +58,8 @@ def capture(fut, tb):
     def getargspec(func):
         # This was deprecated in Python 3.
         return inspect.getargspec(func)
+
+
 else:
     from functools import wraps  # noqa
 
@@ -80,13 +85,13 @@ def find_ordinal(pos_num):
     if pos_num == 0:
         return "th"
     elif pos_num == 1:
-        return 'st'
+        return "st"
     elif pos_num == 2:
-        return 'nd'
+        return "nd"
     elif pos_num == 3:
-        return 'rd'
+        return "rd"
     elif pos_num >= 4 and pos_num <= 20:
-        return 'th'
+        return "th"
     else:
         return find_ordinal(pos_num % 10)
 

src/pip/_vendor/tenacity/after.py

@@ -23,13 +23,18 @@ def after_nothing(retry_state):
 
 def after_log(logger, log_level, sec_format="%0.3f"):
     """After call strategy that logs to some logger the finished attempt."""
-    log_tpl = ("Finished call to '%s' after " + str(sec_format) + "(s), "
-               "this was the %s time calling it.")
+    log_tpl = (
+        "Finished call to '%s' after " + str(sec_format) + "(s), "
+        "this was the %s time calling it."
+    )
 
     def log_it(retry_state):
-        logger.log(log_level, log_tpl,
-                   _utils.get_callback_name(retry_state.fn),
-                   retry_state.seconds_since_start,
-                   _utils.to_ordinal(retry_state.attempt_number))
+        logger.log(
+            log_level,
+            log_tpl,
+            _utils.get_callback_name(retry_state.fn),
+            retry_state.seconds_since_start,
+            _utils.to_ordinal(retry_state.attempt_number),
+        )
 
     return log_it