python-backoff 2.3.1__py3-none-any.whl → 3.0.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
backoff/_sync.py CHANGED
@@ -1,144 +1,240 @@
1
+ from __future__ import annotations
2
+
1
3
  import functools
2
4
  import time
3
-
4
- from backoff._common import _init_wait_gen, _maybe_call, _next_wait
5
-
6
-
7
- def _call_handlers(hdlrs, target, args, kwargs, tries, elapsed, **extra):
8
- details = {
5
+ from typing import TYPE_CHECKING, Any, TypeVar
6
+
7
+ from backoff._common import Attempt, _dispatch_handlers, _RetryState
8
+
9
+ if TYPE_CHECKING:
10
+ import sys
11
+ from collections.abc import Callable, Generator, Iterable
12
+ from typing import ParamSpec
13
+
14
+ from backoff._typing import (
15
+ ContextDetails,
16
+ Details,
17
+ _BaseDetails,
18
+ _CallDetails,
19
+ _ContextHandler,
20
+ _Handler,
21
+ _Jitterer,
22
+ _MaybeCallable,
23
+ _MaybeTuple,
24
+ _Predicate,
25
+ _WaitGenerator,
26
+ )
27
+
28
+ if sys.version_info >= (3, 11):
29
+ from typing import Unpack
30
+ else:
31
+ from typing_extensions import Unpack
32
+
33
+ T = TypeVar("T")
34
+ P = ParamSpec("P")
35
+
36
+
37
+ def _call_handlers(
38
+ hdlrs: Iterable[_Handler],
39
+ target: Callable[..., Any],
40
+ args: tuple[Any, ...],
41
+ kwargs: dict[str, Any],
42
+ tries: int,
43
+ elapsed: float,
44
+ **extra: Unpack[_CallDetails],
45
+ ) -> None:
46
+ details: Details = {
9
47
  "target": target,
10
48
  "args": args,
11
49
  "kwargs": kwargs,
12
50
  "tries": tries,
13
51
  "elapsed": elapsed,
52
+ **extra,
14
53
  }
15
- details.update(extra)
16
54
  for hdlr in hdlrs:
17
55
  hdlr(details)
18
56
 
19
57
 
20
58
  def retry_predicate(
21
- target,
22
- wait_gen,
23
- predicate,
59
+ target: Callable[P, T],
60
+ wait_gen: _WaitGenerator,
61
+ predicate: _Predicate[T],
24
62
  *,
25
- max_tries,
26
- max_time,
27
- jitter,
28
- on_success,
29
- on_backoff,
30
- on_giveup,
31
- wait_gen_kwargs,
32
- ):
63
+ max_tries: _MaybeCallable[int] | None,
64
+ max_time: _MaybeCallable[float] | None,
65
+ jitter: _Jitterer | None,
66
+ on_try: Iterable[_Handler],
67
+ on_success: Iterable[_Handler],
68
+ on_backoff: Iterable[_Handler],
69
+ on_giveup: Iterable[_Handler],
70
+ wait_gen_kwargs: dict[str, Any],
71
+ ) -> Callable[P, T]:
33
72
  @functools.wraps(target)
34
- def retry(*args, **kwargs):
35
- max_tries_value = _maybe_call(max_tries)
36
- max_time_value = _maybe_call(max_time)
37
-
38
- tries = 0
39
- start = time.monotonic()
40
- wait = _init_wait_gen(wait_gen, wait_gen_kwargs)
73
+ def retry(*args: P.args, **kwargs: P.kwargs) -> T:
74
+ state = _RetryState(
75
+ wait_gen,
76
+ wait_gen_kwargs,
77
+ max_tries=max_tries,
78
+ max_time=max_time,
79
+ )
41
80
  while True:
42
- tries += 1
43
- elapsed = time.monotonic() - start
44
- details = {
81
+ state.start_attempt()
82
+ details: _BaseDetails = {
45
83
  "target": target,
46
84
  "args": args,
47
85
  "kwargs": kwargs,
48
- "tries": tries,
49
- "elapsed": elapsed,
86
+ "tries": state.tries,
87
+ "elapsed": state.elapsed,
50
88
  }
51
-
89
+ _call_handlers(on_try, **details)
52
90
  ret = target(*args, **kwargs)
53
- if predicate(ret):
54
- max_tries_exceeded = tries == max_tries_value
55
- max_time_exceeded = (
56
- max_time_value is not None and elapsed >= max_time_value
57
- )
91
+ details["elapsed"] = state.record_elapsed()
58
92
 
59
- if max_tries_exceeded or max_time_exceeded:
93
+ if predicate(ret):
94
+ if state.exhausted():
60
95
  _call_handlers(on_giveup, **details, value=ret)
61
96
  break
62
97
 
63
98
  try:
64
- seconds = _next_wait(wait, ret, jitter, elapsed, max_time_value)
99
+ seconds = state.next_wait(ret, jitter)
65
100
  except StopIteration:
66
- _call_handlers(on_giveup, **details)
101
+ _call_handlers(on_giveup, **details, value=ret)
67
102
  break
68
103
 
69
104
  _call_handlers(on_backoff, **details, value=ret, wait=seconds)
70
105
 
71
106
  time.sleep(seconds)
72
107
  continue
73
- else:
74
- _call_handlers(on_success, **details, value=ret)
75
- break
108
+ _call_handlers(on_success, **details, value=ret)
109
+ break
76
110
 
77
111
  return ret
78
112
 
79
113
  return retry
80
114
 
81
115
 
116
+ def _adapt_context_handlers(
117
+ handlers: Iterable[_Handler],
118
+ target: Callable[..., Any],
119
+ args: tuple[Any, ...],
120
+ kwargs: dict[str, Any],
121
+ ) -> list[_ContextHandler]:
122
+ def adapted(details: ContextDetails) -> None:
123
+ full_details: Details = {
124
+ "target": target,
125
+ "args": args,
126
+ "kwargs": kwargs,
127
+ **details,
128
+ }
129
+ for hdlr in handlers:
130
+ hdlr(full_details)
131
+
132
+ return [adapted]
133
+
134
+
82
135
  def retry_exception(
83
- target,
84
- wait_gen,
85
- exception,
136
+ target: Callable[P, T],
137
+ wait_gen: _WaitGenerator,
138
+ exception: _MaybeTuple[type[Exception]],
86
139
  *,
87
- max_tries,
88
- max_time,
89
- jitter,
90
- giveup,
91
- on_success,
92
- on_backoff,
93
- on_giveup,
94
- raise_on_giveup,
95
- wait_gen_kwargs,
96
- ):
140
+ max_tries: _MaybeCallable[int] | None,
141
+ max_time: _MaybeCallable[float] | None,
142
+ jitter: _Jitterer | None,
143
+ giveup: _Predicate[Exception],
144
+ on_try: Iterable[_Handler],
145
+ on_success: Iterable[_Handler],
146
+ on_backoff: Iterable[_Handler],
147
+ on_giveup: Iterable[_Handler],
148
+ raise_on_giveup: bool,
149
+ wait_gen_kwargs: dict[str, Any],
150
+ ) -> Callable[P, T]:
97
151
  @functools.wraps(target)
98
- def retry(*args, **kwargs):
99
- max_tries_value = _maybe_call(max_tries)
100
- max_time_value = _maybe_call(max_time)
101
-
102
- tries = 0
103
- start = time.monotonic()
104
- wait = _init_wait_gen(wait_gen, wait_gen_kwargs)
105
- while True:
106
- tries += 1
107
- elapsed = time.monotonic() - start
108
- details = {
109
- "target": target,
110
- "args": args,
111
- "kwargs": kwargs,
112
- "tries": tries,
113
- "elapsed": elapsed,
114
- }
115
-
116
- try:
152
+ def retry(*args: P.args, **kwargs: P.kwargs) -> T:
153
+ ret: T = None # type: ignore[assignment] # ty:ignore[invalid-assignment]
154
+
155
+ for attempt in retry_context(
156
+ exception,
157
+ wait_gen,
158
+ max_tries=max_tries,
159
+ max_time=max_time,
160
+ jitter=jitter,
161
+ giveup=giveup, # type: ignore[arg-type] # ty:ignore[invalid-argument-type]
162
+ on_try=_adapt_context_handlers(on_try, target, args, kwargs),
163
+ on_success=_adapt_context_handlers(on_success, target, args, kwargs),
164
+ on_backoff=_adapt_context_handlers(on_backoff, target, args, kwargs),
165
+ on_giveup=_adapt_context_handlers(on_giveup, target, args, kwargs),
166
+ raise_on_giveup=raise_on_giveup,
167
+ wait_gen_kwargs=wait_gen_kwargs,
168
+ ):
169
+ with attempt:
117
170
  ret = target(*args, **kwargs)
118
- except exception as e:
119
- max_tries_exceeded = tries == max_tries_value
120
- max_time_exceeded = (
121
- max_time_value is not None and elapsed >= max_time_value
122
- )
123
-
124
- if giveup(e) or max_tries_exceeded or max_time_exceeded:
125
- _call_handlers(on_giveup, **details, exception=e)
126
- if raise_on_giveup:
127
- raise
128
- return None
129
171
 
130
- try:
131
- seconds = _next_wait(wait, e, jitter, elapsed, max_time_value)
132
- except StopIteration:
133
- _call_handlers(on_giveup, **details, exception=e)
134
- raise e
135
-
136
- _call_handlers(on_backoff, **details, wait=seconds, exception=e)
172
+ return ret
137
173
 
138
- time.sleep(seconds)
139
- else:
140
- _call_handlers(on_success, **details)
174
+ return retry
141
175
 
142
- return ret
143
176
 
144
- return retry
177
+ def retry_context(
178
+ exception: _MaybeTuple[type[Exception]],
179
+ wait_gen: _WaitGenerator,
180
+ *,
181
+ max_tries: _MaybeCallable[int] | None,
182
+ max_time: _MaybeCallable[float] | None,
183
+ jitter: _Jitterer | None,
184
+ giveup: _Predicate[BaseException],
185
+ on_try: Iterable[_ContextHandler],
186
+ on_success: Iterable[_ContextHandler],
187
+ on_backoff: Iterable[_ContextHandler],
188
+ on_giveup: Iterable[_ContextHandler],
189
+ raise_on_giveup: bool,
190
+ wait_gen_kwargs: dict[str, Any],
191
+ ) -> Generator[Attempt, None, None]:
192
+ state = _RetryState(
193
+ wait_gen,
194
+ wait_gen_kwargs,
195
+ max_tries=max_tries,
196
+ max_time=max_time,
197
+ )
198
+ while True:
199
+ state.start_attempt()
200
+ attempt = Attempt(exception)
201
+ _dispatch_handlers(handlers=on_try, tries=state.tries, elapsed=state.elapsed)
202
+ yield attempt
203
+ elapsed = state.record_elapsed()
204
+
205
+ exc = attempt.exception
206
+ if exc is None:
207
+ _dispatch_handlers(on_success, tries=state.tries, elapsed=elapsed)
208
+ return
209
+
210
+ if giveup(exc) or state.exhausted():
211
+ _dispatch_handlers(
212
+ on_giveup,
213
+ tries=state.tries,
214
+ elapsed=elapsed,
215
+ exception=exc,
216
+ )
217
+ if raise_on_giveup:
218
+ raise exc
219
+ return
220
+
221
+ try:
222
+ seconds = state.next_wait(exc, jitter)
223
+ except StopIteration:
224
+ _dispatch_handlers(
225
+ on_giveup,
226
+ tries=state.tries,
227
+ elapsed=elapsed,
228
+ exception=exc,
229
+ )
230
+ raise exc from None
231
+
232
+ _dispatch_handlers(
233
+ on_backoff,
234
+ tries=state.tries,
235
+ elapsed=elapsed,
236
+ wait=seconds,
237
+ exception=exc,
238
+ )
239
+
240
+ time.sleep(seconds)
backoff/_typing.py CHANGED
@@ -1,43 +1,58 @@
1
+ from __future__ import annotations
2
+
1
3
  import logging
2
- from types import FunctionType
3
- from typing import (
4
- Any,
5
- Callable,
6
- Coroutine,
7
- Dict,
8
- Generator,
9
- Sequence,
10
- Tuple,
11
- TypedDict,
12
- TypeVar,
13
- Union,
14
- )
4
+ from collections.abc import Callable, Coroutine, Generator
5
+ from typing import Any, TypeAlias, TypedDict, TypeVar
15
6
 
16
7
 
17
- class _Details(TypedDict):
18
- target: FunctionType
19
- args: Tuple[Any, ...]
20
- kwargs: Dict[str, Any]
8
+ class _BaseDetails(TypedDict):
9
+ target: Callable[..., Any]
10
+ args: tuple[Any, ...]
11
+ kwargs: dict[str, Any]
21
12
  tries: int
22
13
  elapsed: float
23
14
 
24
15
 
25
- class Details(_Details, total=False):
16
+ class _CallDetails(TypedDict, total=False):
26
17
  wait: float # present in the on_backoff handler case for either decorator
27
18
  value: Any # present in the on_predicate decorator case
28
19
  exception: Exception # present in the on_exception decorator case
29
20
 
30
21
 
22
+ class Details(_BaseDetails, _CallDetails, total=False):
23
+ pass
24
+
25
+
26
+ class _BaseContextDetails(TypedDict):
27
+ tries: int
28
+ elapsed: float
29
+
30
+
31
+ class _ContextCallDetails(TypedDict, total=False):
32
+ wait: float # present in the on_backoff handler case
33
+ value: Any # present in the on_predicate decorator case
34
+ exception: Exception # present in the on_giveup handler case
35
+
36
+
37
+ class ContextDetails(_BaseContextDetails, _ContextCallDetails, total=False):
38
+ """Details passed to handlers registered with `retry_context`/`aretry_context`.
39
+
40
+ Unlike `Details`, there's no wrapped callable, so no `target`/`args`/`kwargs`.
41
+ """
42
+
43
+
31
44
  T = TypeVar("T")
32
45
 
33
- _CallableT = TypeVar("_CallableT", bound=Callable[..., Any])
34
- _Handler = Union[
35
- Callable[[Details], None],
36
- Callable[[Details], Coroutine[Any, Any, None]],
37
- ]
46
+ _AnyLogger = logging.Logger | logging.LoggerAdapter # type: ignore[type-arg]
47
+ _AnyLoggerOrName = str | _AnyLogger
48
+ _CallableT = TypeVar("_CallableT", bound=Callable[..., Any]) # ruff:ignore[unused-private-type-var]
49
+ _ContextHandler = (
50
+ Callable[[ContextDetails], None]
51
+ | Callable[[ContextDetails], Coroutine[Any, Any, None]]
52
+ )
53
+ _Handler = Callable[[Details], None] | Callable[[Details], Coroutine[Any, Any, None]]
38
54
  _Jitterer = Callable[[float], float]
39
- _MaybeCallable = Union[T, Callable[[], T]]
40
- _MaybeLogger = Union[str, logging.Logger, logging.LoggerAdapter, None]
41
- _MaybeSequence = Union[T, Sequence[T]]
42
- _Predicate = Callable[[T], bool]
43
- _WaitGenerator = Callable[..., Generator[float, None, None]]
55
+ _MaybeCallable: TypeAlias = T | Callable[[], T] # ruff: ignore[unused-private-type-alias]
56
+ _MaybeTuple: TypeAlias = T | tuple[T, ...] # ruff: ignore[unused-private-type-alias]
57
+ _Predicate = Callable[[T], bool] | Callable[[T], Coroutine[Any, Any, bool]]
58
+ _WaitGenerator = Callable[..., Generator[float, Any, None]]
backoff/_wait_gen.py CHANGED
@@ -1,12 +1,17 @@
1
+ from __future__ import annotations
2
+
1
3
  import itertools
2
4
  import math
3
- from typing import Any, Callable, Generator, Iterable, Optional, Union
5
+ from typing import TYPE_CHECKING, Any
6
+
7
+ if TYPE_CHECKING:
8
+ from collections.abc import Callable, Generator, Iterable
4
9
 
5
10
 
6
11
  def expo(
7
12
  base: float = 2,
8
13
  factor: float = 1,
9
- max_value: Optional[float] = None,
14
+ max_value: float | None = None,
10
15
  ) -> Generator[float, Any, None]:
11
16
  """Generator for exponential decay.
12
17
 
@@ -18,21 +23,20 @@ def expo(
18
23
  of max_value will forever after be yielded.
19
24
  """
20
25
  # Advance past initial .send() call
21
- yield # type: ignore[misc]
22
- base_n: float = 1
26
+ yield 0
27
+
28
+ a = factor
29
+ while max_value is None or a < max_value:
30
+ yield a
31
+ a *= base
23
32
  while True:
24
- a = factor * base_n
25
- if max_value is None or a < max_value:
26
- yield a
27
- base_n *= base
28
- else:
29
- yield max_value
33
+ yield max_value
30
34
 
31
35
 
32
36
  def decay(
33
37
  initial_value: float = 1,
34
38
  decay_factor: float = 1,
35
- min_value: Optional[float] = None,
39
+ min_value: float | None = None,
36
40
  ) -> Generator[float, Any, None]:
37
41
  """Generator for exponential decay[1]:
38
42
 
@@ -46,18 +50,17 @@ def decay(
46
50
  [1] https://en.wikipedia.org/wiki/Exponential_decay
47
51
  """
48
52
  # Advance past initial .send() call
49
- yield # type: ignore[misc]
50
- t = 0
53
+ yield 0
54
+ a = initial_value
55
+ min_value = min_value or 0.0
56
+ while a > min_value:
57
+ yield a
58
+ a *= math.exp(-decay_factor)
51
59
  while True:
52
- a = initial_value * math.e ** (-t * decay_factor)
53
- if min_value is None or a > min_value:
54
- yield a
55
- t += 1
56
- else:
57
- yield min_value
60
+ yield min_value
58
61
 
59
62
 
60
- def fibo(max_value: Optional[int] = None) -> Generator[int, None, None]:
63
+ def fibo(max_value: int | None = None) -> Generator[int, Any, None]:
61
64
  """Generator for fibonaccial decay.
62
65
 
63
66
  Args:
@@ -66,50 +69,66 @@ def fibo(max_value: Optional[int] = None) -> Generator[int, None, None]:
66
69
  of max_value will forever after be yielded.
67
70
  """
68
71
  # Advance past initial .send() call
69
- yield # type: ignore[misc]
72
+ yield 0
70
73
 
71
74
  a = 1
72
75
  b = 1
76
+ while max_value is None or a < max_value:
77
+ yield a
78
+ a, b = b, a + b
73
79
  while True:
74
- if max_value is None or a < max_value:
75
- yield a
76
- a, b = b, a + b
77
- else:
78
- yield max_value
80
+ yield max_value
79
81
 
80
82
 
81
- def constant(
82
- interval: Union[int, Iterable[float]] = 1,
83
- ) -> Generator[float, None, None]:
83
+ def constant(interval: float | Iterable[float] = 1) -> Generator[float, Any, None]:
84
84
  """Generator for constant intervals.
85
85
 
86
86
  Args:
87
87
  interval: A constant value to yield or an iterable of such values.
88
88
  """
89
89
  # Advance past initial .send() call
90
- yield # type: ignore[misc]
90
+ yield 0
91
91
 
92
- try:
93
- itr = iter(interval) # type: ignore
94
- except TypeError:
95
- itr = itertools.repeat(interval) # type: ignore
92
+ itr = (
93
+ itertools.repeat(interval)
94
+ if isinstance(interval, (int, float))
95
+ else iter(interval)
96
+ )
96
97
 
97
98
  for val in itr:
98
99
  yield val
99
100
 
100
101
 
101
- def runtime(
102
- *,
103
- value: Callable[[Any], float],
104
- ) -> Generator[float, None, None]:
102
+ def runtime(*, value: Callable[[Any], float]) -> Generator[float, Any, None]:
105
103
  """Generator that is based on parsing the return value or thrown
106
104
  exception of the decorated method
107
105
 
106
+ Useful for honoring a server-specified retry delay, e.g. an HTTP
107
+ `Retry-After` header, rather than a fixed wait sequence:
108
+
109
+ # with on_predicate, `value` receives the return value
110
+ @backoff.on_predicate(
111
+ backoff.runtime,
112
+ predicate=lambda r: r.status_code == 429,
113
+ value=lambda r: int(r.headers.get("Retry-After", 1)),
114
+ )
115
+ def get_page():
116
+ return requests.get(url)
117
+
118
+ # with on_exception, `value` receives the raised exception
119
+ @backoff.on_exception(
120
+ backoff.runtime,
121
+ RetryableError,
122
+ value=lambda e: e.wait_seconds,
123
+ )
124
+ def get_page():
125
+ ...
126
+
108
127
  Args:
109
128
  value: a callable which takes as input the decorated
110
129
  function's return value or thrown exception and
111
130
  determines how long to wait
112
131
  """
113
- ret_or_exc = yield # type: ignore[misc]
132
+ ret_or_exc = yield 0
114
133
  while True:
115
134
  ret_or_exc = yield value(ret_or_exc)
backoff/types.py CHANGED
@@ -1,5 +1,6 @@
1
- from ._typing import Details
1
+ from ._typing import ContextDetails, Details
2
2
 
3
3
  __all__ = [
4
+ "ContextDetails",
4
5
  "Details",
5
6
  ]
@@ -1,6 +1,6 @@
1
- Metadata-Version: 2.4
1
+ Metadata-Version: 2.5
2
2
  Name: python-backoff
3
- Version: 2.3.1
3
+ Version: 3.0.0
4
4
  Summary: Function decoration for backoff and retry
5
5
  Project-URL: Documentation, https://python-backoff.github.io/backoff
6
6
  Project-URL: Repository, https://github.com/python-backoff/backoff
@@ -11,13 +11,10 @@ License-File: LICENSE
11
11
  Keywords: backoff,decorators,retry
12
12
  Classifier: Development Status :: 5 - Production/Stable
13
13
  Classifier: Intended Audience :: Developers
14
- Classifier: License :: OSI Approved :: MIT License
15
14
  Classifier: Natural Language :: English
16
15
  Classifier: Operating System :: OS Independent
17
16
  Classifier: Programming Language :: Python
18
17
  Classifier: Programming Language :: Python :: 3
19
- Classifier: Programming Language :: Python :: 3.8
20
- Classifier: Programming Language :: Python :: 3.9
21
18
  Classifier: Programming Language :: Python :: 3.10
22
19
  Classifier: Programming Language :: Python :: 3.11
23
20
  Classifier: Programming Language :: Python :: 3.12
@@ -27,7 +24,7 @@ Classifier: Programming Language :: Python :: 3.15
27
24
  Classifier: Topic :: Internet :: WWW/HTTP
28
25
  Classifier: Topic :: Software Development :: Libraries :: Python Modules
29
26
  Classifier: Topic :: Utilities
30
- Requires-Python: >=3.8
27
+ Requires-Python: >=3.10
31
28
  Description-Content-Type: text/x-rst
32
29
 
33
30
  backoff
@@ -406,7 +403,7 @@ asynchronous HTTP client/server library.
406
403
  max_time=60,
407
404
  )
408
405
  async def get_url(url):
409
- async with aiohttp.ClientSession(raise_for_status=True) as session: # noqa: SIM117
406
+ async with aiohttp.ClientSession(raise_for_status=True) as session: # ruff:ignore[multiple-with-statements]
410
407
  async with session.get(url) as response:
411
408
  return await response.text()
412
409
 
@@ -0,0 +1,14 @@
1
+ backoff/__init__.py,sha256=_AGhwnTFSCdB_oeBA1-X5HPaivH4At8qucG8WQ8kZjI,1039
2
+ backoff/_async.py,sha256=UMAls92zTDOc_W8nmaTIWAEznQgE-bnSCjfoYerVG9Q,9235
3
+ backoff/_common.py,sha256=0ONXWZBiAMSAXw4KN_Cp7mLvhlUPOGV826NHYn6E760,8342
4
+ backoff/_decorator.py,sha256=loMJ2ep7O0KOeXL8vvyMFU9VGK2fKlSsUaZoVCT5Tfs,18110
5
+ backoff/_jitter.py,sha256=wzQHBDNuYg7owbc3fcZLOr5uhhRgqiuncU5rIYOB9lY,766
6
+ backoff/_sync.py,sha256=bUoAkIBUB1TEyvSvHQSulesSjuyvRxD6Lq2SbLcw96o,6710
7
+ backoff/_typing.py,sha256=ZMEhNamBlnXcOqzSCvGqZZ0uc0KVu9-mOKcxccCCPAs,1996
8
+ backoff/_wait_gen.py,sha256=J7-UEqBjxdxvj7LKb5D1ILfPzMrUmCIVX0YsvS107UQ,3752
9
+ backoff/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
10
+ backoff/types.py,sha256=obBefroeCaGlPbOQSw1KIKvYl4SKFr8_YvwogvorVnw,97
11
+ python_backoff-3.0.0.dist-info/METADATA,sha256=n9RmkgXbEsR9yRYThMaw0tk7KFaPG6eNIKO_TX5WRBI,14760
12
+ python_backoff-3.0.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
13
+ python_backoff-3.0.0.dist-info/licenses/LICENSE,sha256=KmtNX4hNTXob8E6n3xlEzxKzLjWnmobQoHWi0_QPuaw,1077
14
+ python_backoff-3.0.0.dist-info/RECORD,,
@@ -1,4 +1,4 @@
1
1
  Wheel-Version: 1.0
2
- Generator: hatchling 1.28.0
2
+ Generator: hatchling 1.32.0
3
3
  Root-Is-Purelib: true
4
4
  Tag: py3-none-any
@@ -1,14 +0,0 @@
1
- backoff/__init__.py,sha256=MS4ieVYpjBh-feDqzJHYJy8mjnuEEaprTWWuXgJI-1A,914
2
- backoff/_async.py,sha256=Ehv3H3jMF9JylzZzHTLSLwK_s0PoJa_1jeGo3qtpcOY,6370
3
- backoff/_common.py,sha256=Q8ZB8mCMI76WLii8JcrfoSZc11WRqu7ci_mpG1y-j9Y,3460
4
- backoff/_decorator.py,sha256=61iXFb5jN2mQ9-1mtRPi_gysJwuyhkKrbDVNWH8GDxo,9483
5
- backoff/_jitter.py,sha256=wzQHBDNuYg7owbc3fcZLOr5uhhRgqiuncU5rIYOB9lY,766
6
- backoff/_sync.py,sha256=7W0aTlntrL237rfhy2yaFklZheQoYxBTD5F_4TUarQI,3867
7
- backoff/_typing.py,sha256=hO065un_HjJEsEa_OgW66JZRyxVf-BsJ9HrswIwW3fA,1056
8
- backoff/_wait_gen.py,sha256=ZTZfs4WiI295EvOJeJYPIUAABQ0WBAKcvUtg0_ZId8k,3244
9
- backoff/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
10
- backoff/types.py,sha256=rOQAfuetqVwfEIuzVvK5D_w97A3wrZ9lQ8HwuJ_uq5s,59
11
- python_backoff-2.3.1.dist-info/METADATA,sha256=o7ltpQ3fk4s05tUCVIeUgZVzGFfigmw06jNoz6HM6RI,14885
12
- python_backoff-2.3.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
13
- python_backoff-2.3.1.dist-info/licenses/LICENSE,sha256=KmtNX4hNTXob8E6n3xlEzxKzLjWnmobQoHWi0_QPuaw,1077
14
- python_backoff-2.3.1.dist-info/RECORD,,