diff options
| author | CoprDistGit <infra@openeuler.org> | 2023-04-12 05:45:28 +0000 |
|---|---|---|
| committer | CoprDistGit <infra@openeuler.org> | 2023-04-12 05:45:28 +0000 |
| commit | d9358e107cae18762b461e9283d9824ac06aa19a (patch) | |
| tree | aa72d6c25113da8cf2622142b37567a0c081a9b0 /python-waiter.spec | |
| parent | 5e4cd8c43772f17550d0bc5c529fa07a5265c75a (diff) | |
automatic import of python-waiter
Diffstat (limited to 'python-waiter.spec')
| -rw-r--r-- | python-waiter.spec | 526 |
1 files changed, 526 insertions, 0 deletions
diff --git a/python-waiter.spec b/python-waiter.spec new file mode 100644 index 0000000..171b92e --- /dev/null +++ b/python-waiter.spec @@ -0,0 +1,526 @@ +%global _empty_manifest_terminate_build 0 +Name: python-waiter +Version: 1.3 +Release: 1 +Summary: Delayed iteration for polling and retries. +License: Copyright 2022 Aric Coady Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. +URL: https://github.com/coady/waiter +Source0: https://mirrors.nju.edu.cn/pypi/web/packages/1d/6e/b6c3535be3995bd076593767735d24858ad95c66310def04754460eb9143/waiter-1.3.tar.gz +BuildArch: noarch + +Requires: python3-multimethod + +%description +[](https://pypi.org/project/waiter/) + +[](https://pepy.tech/project/waiter) + +[](https://github.com/coady/waiter/actions) +[](https://codecov.io/gh/coady/waiter/) +[](https://github.com/coady/waiter/security/code-scanning) +[](https://pypi.org/project/black/) +[](http://mypy-lang.org/) + +Does Python need yet another retry / poll library? It needs at least one that isn't coupled to decorators and functions. Decorators prevent the caller from customizing delay options, and organizing the code around functions hinders any custom handling of failures. + +Waiter is built around iteration instead, because the foundation of retrying / polling is a slowly executing loop. The resulting interface is both easier to use and more flexible, decoupling the delay algorithms from the application logic. + +## Usage +### creation +Supply a number of seconds to repeat endlessly, or any iterable of seconds. + +```python +from waiter import wait + +wait(1) # 1, 1, 1, 1, ... +wait([1] * 3) # 1, 1, 1 +wait([0.5, 0.5, 60]) # circuit breaker +``` + +Iterable delays can express any waiting strategy, and constructors for common algorithms are also provided. + +```python +wait.count(1) # incremental backoff 1, 2, 3, 4, 5, ... +wait(1) + 1 # alternate syntax 1, 2, 3, 4, 5, ... +wait.fibonacci(1) # 1, 1, 2, 3, 5, ... +wait.polynomial(2) # 0, 1, 4, 9, 16, ... + +wait.exponential(2) # exponential backoff 1, 2, 4, 8, ... +backoff = wait(1) * 2 # alternate syntax 1, 2, 4, 8, ... +backoff[:3] # limit attempt count 1, 2, 4 +backoff <= 5 # set maximum delay 1, 2, 4, 5, 5, 5, ... +backoff.random(-1, 1) # add random jitter +``` + +### iteration +Then simply use the `wait` object like any iterable, yielding the amount of elapsed time. Timeouts also supported of course. + +```python +from waiter import wait, suppress, first + +for elapsed in wait(delays): # first iteration is immediate + with suppress(exception): # then each subsequent iteration sleeps as necessary + ... + break + +for _ in wait(delays, timeout): # standard convention for ignoring a loop variable + ... # won't sleep past the timeout + if ...: + break + +results = (... for _ in wait(delays)) # expressions are even easier +first(predicate, results[, default]) # filter for first true item +assert any(results) # perfect for tests too +``` + +### functions +Yes, functional versions are provided, as well as being trivial to implement. + +```python +wait(...).throttle(iterable) # generate items from iterable +wait(...).repeat(func, *args, **kwargs) # generate successive results +wait(...).retry(exception, func, *args, **kwargs) # return first success or re-raise exception +wait(...).poll(predicate, func, *args, **kwargs) # return first success or raise StopIteration +``` + +The decorator variants are simply partial applications of the corresponding methods. Note decorator syntax doesn't support arbitrary expressions. + +```python +backoff = wait(0.1) * 2 +@backoff.repeating +@backoff.retrying(exception) +@backoff.polling(predicate) +``` + +But in the real world: +* the function may not exist or be succinctly written as a lambda +* the predicate may not exist or be succinctly written as a lambda +* logging may be required +* there may be complex handling of different exceptions or results + +So consider the block form, just as decorators don't render `with` blocks superfluous. Also note `wait` objects are re-iterable provided their original delays were. + +### async +Waiters also support async iteration. `throttle` optionally accepts an async iterable. `repeat`, `retry`, and `poll` optionally accept coroutine functions. + +### statistics +Waiter objects have a `stats` attribute for aggregating statistics about the calls made. The base implementation provides `total` and `failure` counts. The interface of the `stats` object itself is considered provisional for now, but can be extended by overriding the `Stats` class attribute. This also allows customization of the iterable values; elapsed time is the default. + +## Installation +```console +% pip install waiter +``` + +## Dependencies +* multimethod + +## Tests +100% branch coverage. + +```console +% pytest [--cov] +``` + +## Changes +1.3 + +* Python >=3.7 required + +1.2 + +* Python >=3.6 required + +1.1 + +* Stream from sized groups + +1.0 + +* Map a function across an iterable in batches + +0.6 + +* Extensible iterable values and statistics +* Additional constructors: fibonacci, polynomial, accumulate + +0.5 + +* Asynchronous iteration + +0.4 + +* Decorators support methods +* Iterables can be throttled + +0.3 + +* Waiters behave as iterables instead of iterators +* Support for function decorators + +0.2 + +* `suppress` context manager for exception handling +* `repeat` method for decoupled iteration +* `first` function for convenient filtering + + +%package -n python3-waiter +Summary: Delayed iteration for polling and retries. +Provides: python-waiter +BuildRequires: python3-devel +BuildRequires: python3-setuptools +BuildRequires: python3-pip +%description -n python3-waiter +[](https://pypi.org/project/waiter/) + +[](https://pepy.tech/project/waiter) + +[](https://github.com/coady/waiter/actions) +[](https://codecov.io/gh/coady/waiter/) +[](https://github.com/coady/waiter/security/code-scanning) +[](https://pypi.org/project/black/) +[](http://mypy-lang.org/) + +Does Python need yet another retry / poll library? It needs at least one that isn't coupled to decorators and functions. Decorators prevent the caller from customizing delay options, and organizing the code around functions hinders any custom handling of failures. + +Waiter is built around iteration instead, because the foundation of retrying / polling is a slowly executing loop. The resulting interface is both easier to use and more flexible, decoupling the delay algorithms from the application logic. + +## Usage +### creation +Supply a number of seconds to repeat endlessly, or any iterable of seconds. + +```python +from waiter import wait + +wait(1) # 1, 1, 1, 1, ... +wait([1] * 3) # 1, 1, 1 +wait([0.5, 0.5, 60]) # circuit breaker +``` + +Iterable delays can express any waiting strategy, and constructors for common algorithms are also provided. + +```python +wait.count(1) # incremental backoff 1, 2, 3, 4, 5, ... +wait(1) + 1 # alternate syntax 1, 2, 3, 4, 5, ... +wait.fibonacci(1) # 1, 1, 2, 3, 5, ... +wait.polynomial(2) # 0, 1, 4, 9, 16, ... + +wait.exponential(2) # exponential backoff 1, 2, 4, 8, ... +backoff = wait(1) * 2 # alternate syntax 1, 2, 4, 8, ... +backoff[:3] # limit attempt count 1, 2, 4 +backoff <= 5 # set maximum delay 1, 2, 4, 5, 5, 5, ... +backoff.random(-1, 1) # add random jitter +``` + +### iteration +Then simply use the `wait` object like any iterable, yielding the amount of elapsed time. Timeouts also supported of course. + +```python +from waiter import wait, suppress, first + +for elapsed in wait(delays): # first iteration is immediate + with suppress(exception): # then each subsequent iteration sleeps as necessary + ... + break + +for _ in wait(delays, timeout): # standard convention for ignoring a loop variable + ... # won't sleep past the timeout + if ...: + break + +results = (... for _ in wait(delays)) # expressions are even easier +first(predicate, results[, default]) # filter for first true item +assert any(results) # perfect for tests too +``` + +### functions +Yes, functional versions are provided, as well as being trivial to implement. + +```python +wait(...).throttle(iterable) # generate items from iterable +wait(...).repeat(func, *args, **kwargs) # generate successive results +wait(...).retry(exception, func, *args, **kwargs) # return first success or re-raise exception +wait(...).poll(predicate, func, *args, **kwargs) # return first success or raise StopIteration +``` + +The decorator variants are simply partial applications of the corresponding methods. Note decorator syntax doesn't support arbitrary expressions. + +```python +backoff = wait(0.1) * 2 +@backoff.repeating +@backoff.retrying(exception) +@backoff.polling(predicate) +``` + +But in the real world: +* the function may not exist or be succinctly written as a lambda +* the predicate may not exist or be succinctly written as a lambda +* logging may be required +* there may be complex handling of different exceptions or results + +So consider the block form, just as decorators don't render `with` blocks superfluous. Also note `wait` objects are re-iterable provided their original delays were. + +### async +Waiters also support async iteration. `throttle` optionally accepts an async iterable. `repeat`, `retry`, and `poll` optionally accept coroutine functions. + +### statistics +Waiter objects have a `stats` attribute for aggregating statistics about the calls made. The base implementation provides `total` and `failure` counts. The interface of the `stats` object itself is considered provisional for now, but can be extended by overriding the `Stats` class attribute. This also allows customization of the iterable values; elapsed time is the default. + +## Installation +```console +% pip install waiter +``` + +## Dependencies +* multimethod + +## Tests +100% branch coverage. + +```console +% pytest [--cov] +``` + +## Changes +1.3 + +* Python >=3.7 required + +1.2 + +* Python >=3.6 required + +1.1 + +* Stream from sized groups + +1.0 + +* Map a function across an iterable in batches + +0.6 + +* Extensible iterable values and statistics +* Additional constructors: fibonacci, polynomial, accumulate + +0.5 + +* Asynchronous iteration + +0.4 + +* Decorators support methods +* Iterables can be throttled + +0.3 + +* Waiters behave as iterables instead of iterators +* Support for function decorators + +0.2 + +* `suppress` context manager for exception handling +* `repeat` method for decoupled iteration +* `first` function for convenient filtering + + +%package help +Summary: Development documents and examples for waiter +Provides: python3-waiter-doc +%description help +[](https://pypi.org/project/waiter/) + +[](https://pepy.tech/project/waiter) + +[](https://github.com/coady/waiter/actions) +[](https://codecov.io/gh/coady/waiter/) +[](https://github.com/coady/waiter/security/code-scanning) +[](https://pypi.org/project/black/) +[](http://mypy-lang.org/) + +Does Python need yet another retry / poll library? It needs at least one that isn't coupled to decorators and functions. Decorators prevent the caller from customizing delay options, and organizing the code around functions hinders any custom handling of failures. + +Waiter is built around iteration instead, because the foundation of retrying / polling is a slowly executing loop. The resulting interface is both easier to use and more flexible, decoupling the delay algorithms from the application logic. + +## Usage +### creation +Supply a number of seconds to repeat endlessly, or any iterable of seconds. + +```python +from waiter import wait + +wait(1) # 1, 1, 1, 1, ... +wait([1] * 3) # 1, 1, 1 +wait([0.5, 0.5, 60]) # circuit breaker +``` + +Iterable delays can express any waiting strategy, and constructors for common algorithms are also provided. + +```python +wait.count(1) # incremental backoff 1, 2, 3, 4, 5, ... +wait(1) + 1 # alternate syntax 1, 2, 3, 4, 5, ... +wait.fibonacci(1) # 1, 1, 2, 3, 5, ... +wait.polynomial(2) # 0, 1, 4, 9, 16, ... + +wait.exponential(2) # exponential backoff 1, 2, 4, 8, ... +backoff = wait(1) * 2 # alternate syntax 1, 2, 4, 8, ... +backoff[:3] # limit attempt count 1, 2, 4 +backoff <= 5 # set maximum delay 1, 2, 4, 5, 5, 5, ... +backoff.random(-1, 1) # add random jitter +``` + +### iteration +Then simply use the `wait` object like any iterable, yielding the amount of elapsed time. Timeouts also supported of course. + +```python +from waiter import wait, suppress, first + +for elapsed in wait(delays): # first iteration is immediate + with suppress(exception): # then each subsequent iteration sleeps as necessary + ... + break + +for _ in wait(delays, timeout): # standard convention for ignoring a loop variable + ... # won't sleep past the timeout + if ...: + break + +results = (... for _ in wait(delays)) # expressions are even easier +first(predicate, results[, default]) # filter for first true item +assert any(results) # perfect for tests too +``` + +### functions +Yes, functional versions are provided, as well as being trivial to implement. + +```python +wait(...).throttle(iterable) # generate items from iterable +wait(...).repeat(func, *args, **kwargs) # generate successive results +wait(...).retry(exception, func, *args, **kwargs) # return first success or re-raise exception +wait(...).poll(predicate, func, *args, **kwargs) # return first success or raise StopIteration +``` + +The decorator variants are simply partial applications of the corresponding methods. Note decorator syntax doesn't support arbitrary expressions. + +```python +backoff = wait(0.1) * 2 +@backoff.repeating +@backoff.retrying(exception) +@backoff.polling(predicate) +``` + +But in the real world: +* the function may not exist or be succinctly written as a lambda +* the predicate may not exist or be succinctly written as a lambda +* logging may be required +* there may be complex handling of different exceptions or results + +So consider the block form, just as decorators don't render `with` blocks superfluous. Also note `wait` objects are re-iterable provided their original delays were. + +### async +Waiters also support async iteration. `throttle` optionally accepts an async iterable. `repeat`, `retry`, and `poll` optionally accept coroutine functions. + +### statistics +Waiter objects have a `stats` attribute for aggregating statistics about the calls made. The base implementation provides `total` and `failure` counts. The interface of the `stats` object itself is considered provisional for now, but can be extended by overriding the `Stats` class attribute. This also allows customization of the iterable values; elapsed time is the default. + +## Installation +```console +% pip install waiter +``` + +## Dependencies +* multimethod + +## Tests +100% branch coverage. + +```console +% pytest [--cov] +``` + +## Changes +1.3 + +* Python >=3.7 required + +1.2 + +* Python >=3.6 required + +1.1 + +* Stream from sized groups + +1.0 + +* Map a function across an iterable in batches + +0.6 + +* Extensible iterable values and statistics +* Additional constructors: fibonacci, polynomial, accumulate + +0.5 + +* Asynchronous iteration + +0.4 + +* Decorators support methods +* Iterables can be throttled + +0.3 + +* Waiters behave as iterables instead of iterators +* Support for function decorators + +0.2 + +* `suppress` context manager for exception handling +* `repeat` method for decoupled iteration +* `first` function for convenient filtering + + +%prep +%autosetup -n waiter-1.3 + +%build +%py3_build + +%install +%py3_install +install -d -m755 %{buildroot}/%{_pkgdocdir} +if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi +if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi +if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi +if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi +pushd %{buildroot} +if [ -d usr/lib ]; then + find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/lib64 ]; then + find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/bin ]; then + find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/sbin ]; then + find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst +fi +touch doclist.lst +if [ -d usr/share/man ]; then + find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst +fi +popd +mv %{buildroot}/filelist.lst . +mv %{buildroot}/doclist.lst . + +%files -n python3-waiter -f filelist.lst +%dir %{python3_sitelib}/* + +%files help -f doclist.lst +%{_docdir}/* + +%changelog +* Wed Apr 12 2023 Python_Bot <Python_Bot@openeuler.org> - 1.3-1 +- Package Spec generated |