ci: enable black (#277)

doc/source/conf.py

@@ -19,16 +19,16 @@
 import os
 import sys
 
-master_doc = 'index'
+master_doc = "index"
 project = "Tenacity"
 
 # Add tenacity to the path, so sphinx can find the functions for autodoc.
-sys.path.insert(0, os.path.abspath('../..'))
+sys.path.insert(0, os.path.abspath("../.."))
 
 extensions = [
-    'sphinx.ext.doctest',
-    'sphinx.ext.autodoc',
-    'reno.sphinxext',
+    "sphinx.ext.doctest",
+    "sphinx.ext.autodoc",
+    "reno.sphinxext",
 ]
 
 # -- Options for sphinx.ext.doctest  -----------------------------------------

setup.py

@@ -16,6 +16,6 @@
 import setuptools
 
 setuptools.setup(
-    setup_requires=['setuptools_scm'],
+    setup_requires=["setuptools_scm"],
     use_scm_version=True,
 )

tenacity/__init__.py

@@ -115,11 +115,15 @@ def retry(*dargs, **dkw):  # noqa
     if len(dargs) == 1 and callable(dargs[0]):
         return retry()(dargs[0])
     else:
+
         def wrap(f):
             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)
@@ -157,17 +161,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)
@@ -213,16 +218,19 @@ 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
@@ -239,9 +247,17 @@ def __init__(self,
         # Retrying objects but kept for backward compatibility.
         self.fn = None
 
-    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,
+    ):
         """Copy this object with some parameters changed if needed."""
         if before_sleep is _unset:
             before_sleep = self.before_sleep
@@ -258,12 +274,14 @@ def copy(self, sleep=_unset, stop=_unset, wait=_unset,
 
     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):
@@ -298,6 +316,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)
@@ -312,9 +331,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
@@ -324,16 +343,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)
@@ -348,8 +367,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)
@@ -376,8 +395,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)
 
 
@@ -387,8 +408,7 @@ 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):

tenacity/_asyncio.py

@@ -26,18 +26,14 @@
 
 
 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):

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)
 

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

tenacity/before.py

@@ -23,10 +23,13 @@ def before_nothing(retry_state):
 
 def before_log(logger, log_level):
     """Before call strategy that logs to some logger the attempt."""
+
     def log_it(retry_state):
-        logger.log(log_level,
-                   "Starting call to '%s', this is the %s time calling it.",
-                   _utils.get_callback_name(retry_state.fn),
-                   _utils.to_ordinal(retry_state.attempt_number))
+        logger.log(
+            log_level,
+            "Starting call to '%s', this is the %s time calling it.",
+            _utils.get_callback_name(retry_state.fn),
+            _utils.to_ordinal(retry_state.attempt_number),
+        )
 
     return log_it

tenacity/before_sleep.py

@@ -24,23 +24,28 @@ def before_sleep_nothing(retry_state):
 
 def before_sleep_log(logger, log_level, exc_info=False):
     """Before call strategy that logs to some logger the attempt."""
+
     def log_it(retry_state):
         if retry_state.outcome.failed:
             ex = retry_state.outcome.exception()
-            verb, value = 'raised', '%s: %s' % (type(ex).__name__, ex)
+            verb, value = "raised", "%s: %s" % (type(ex).__name__, ex)
 
             if exc_info:
                 local_exc_info = get_exc_info_from_future(retry_state.outcome)
             else:
                 local_exc_info = False
         else:
-            verb, value = 'returned', retry_state.outcome.result()
+            verb, value = "returned", retry_state.outcome.result()
             local_exc_info = False  # exc_info does not apply when no exception
 
-        logger.log(log_level,
-                   "Retrying %s in %s seconds as it %s %s.",
-                   _utils.get_callback_name(retry_state.fn),
-                   getattr(retry_state.next_action, 'sleep'),
-                   verb, value,
-                   exc_info=local_exc_info)
+        logger.log(
+            log_level,
+            "Retrying %s in %s seconds as it %s %s.",
+            _utils.get_callback_name(retry_state.fn),
+            getattr(retry_state.next_action, "sleep"),
+            verb,
+            value,
+            exc_info=local_exc_info,
+        )
+
     return log_it