Metadata-Version: 2.1
Name: trythatagain
Version: 0.1.2
Summary: Decorators for functions that you wish to retry
Home-page: https://github.com/angstwad/trythatagain
Author: Paul Durivage
Author-email: pauldurivage@gmail.com
License: LGPL
Platform: UNKNOWN
Classifier: Topic :: Utilities
Classifier: Intended Audience :: Developers
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3.4
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)
Description-Content-Type: text/markdown
Provides-Extra: test
Provides-Extra: test
Requires-Dist: pytest; extra == 'test'
Requires-Dist: pytest-mock; extra == 'test'
Requires-Dist: flake8; extra == 'test'

# trythatagain

This provides decorators for super simple function/method call retries when an exception is raised.

## Installation

```bash
pip install trythatagain
```

## Examples

Here's a simple use case: querying the AWS API, knowing you might hit API limits.

```python
from trythatagain import retry

@retry
def find_ebs_volumes(unattached=True, no_snapshots=True):
    ...

try:
    find_ebs_volumes()
except CaughtException as e:
    print('Failed to list EBS volumes')
    print(e.caught_exception)
```

This will retry calling `func` three times.  If was not successful in calling the function without an exception, it will re-raise the exception as `CaughtException`, with the original exception available at the attribute `caught_exception`.

Retry as many times as times as necessary:

```python
from trythatagain import retry

@retry(retries=5)
def try_five_times():
    raise Exception('This always fails')

@retry(retries=0)
def retry_forever():
    raise Exception('Terrible waste of CPU cycles')
```

Raise immediately on specific exceptions:

```python
@retry(raise_for=ValueError)
def update_cache():
    ...
```

Suppress re-raising exceptions:

```python
@retry(reraise=False)
def reload_user_data():
    ...
```

There's also exponential and linear backoff retries things like cooling down after hitting API limits.  In fact, AWS recommends exponential backoff to deal with API limits.

```python
# waits 1 second, then 4, then 9, etc.
@retry_exp_backoff(unit=MILLISECONDS)
def update_instance_tags():
    ...

@retry_linear_backoff(unit=SECONDS)
def scrape_url():
    ...
```

Custom wait functions are also possible:

```python
def fixed(i, unit):
    time.sleep(5 * unit)

@retry(wait_func=fixed, unit=MILLISECONDS)
def func():
    ...
```


