Add retries functionality

pynws/__init__.py

@@ -6,6 +6,13 @@
 from .const import version
 from .forecast import DetailedForecast
 from .nws import Nws, NwsError
-from .simple_nws import SimpleNWS
+from .simple_nws import SimpleNWS, call_with_retry
 
-__all__ = ["version", "DetailedForecast", "Nws", "NwsError", "SimpleNWS"]
+__all__ = [
+    "version",
+    "DetailedForecast",
+    "Nws",
+    "NwsError",
+    "SimpleNWS",
+    "call_with_retry",
+]

pynws/simple_nws.py

@@ -4,9 +4,24 @@
 
 from datetime import datetime, timezone
 from statistics import mean
-from typing import Any, Dict, List, NamedTuple, Optional, Set, Tuple, Union
-
-from aiohttp import ClientSession
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Awaitable,
+    Callable,
+    Dict,
+    List,
+    NamedTuple,
+    Optional,
+    Set,
+    Tuple,
+    Union,
+)
+
+if TYPE_CHECKING:
+    from datetime import timedelta
+
+from aiohttp import ClientResponseError, ClientSession
 from metar import Metar
 
 from .const import ALERT_ID, API_WEATHER_CODE, Final
@@ -37,6 +52,53 @@
 WIND: Final = {name: idx * 360 / 16 for idx, name in enumerate(WIND_DIRECTIONS)}
 
 
+def _is_500_error(error: BaseException) -> bool:
+    """Return True if error is ClientResponseError and has a 5xx status."""
+    return isinstance(error, ClientResponseError) and error.status >= 500
+
+
+def _setup_retry_func(
+    func: Callable[[Any, Any], Awaitable[Any]],
+    interval: Union[float, timedelta],
+    stop: Union[float, timedelta],
+) -> Callable[[Any, Any], Awaitable[Any]]:
+    from tenacity import retry, retry_if_exception, stop_after_delay, wait_fixed
+
+    return retry(
+        reraise=True,
+        wait=wait_fixed(interval),
+        stop=stop_after_delay(stop),
+        retry=retry_if_exception(_is_500_error),
+    )(func)
+
+
+async def call_with_retry(
+    func: Callable[[Any, Any], Awaitable[Any]],
+    interval: Union[float, timedelta],
+    stop: Union[float, timedelta],
+    /,
+    *args,
+    **kwargs,
+) -> Callable[[Any, Any], Awaitable[Any]]:
+    """Call an update function with retries.
+
+    Parameters
+    ----------
+    func : Callable
+        An awaitable coroutine to retry.
+    interval : float, datetime.datetime.timedelta
+        Time interval for retry.
+    stop : float, datetime.datetime.timedelta
+        Time interval to stop retrying.
+    args : Any
+        Positional args to pass to func.
+    kwargs : Any
+        Keyword args to pass to func.
+    """
+    retried_func = _setup_retry_func(func, interval, stop)
+    return await retried_func(*args, **kwargs)
+
+
 class MetarParam(NamedTuple):
     """METAR conversion parameter"""
 

requirements-test.txt

@@ -6,4 +6,5 @@ pytest-asyncio==0.23.6
 pytest-cov==5.0.0
 pytest-aiohttp==1.0.5
 mypy==1.9.0
+tenacity==8.2.3
 ruff==0.3.7

requirements.txt

@@ -1,2 +1,3 @@
 aiohttp
 metar
+tenacity

setup.py

@@ -23,6 +23,7 @@
         "aiohttp",
         "metar",
     ],
+    extras_require={"retry": ["tenacity"]},
     python_requires=">=3.8",
     classifiers=[
         "License :: OSI Approved :: MIT License",

tests/helpers.py

@@ -6,15 +6,19 @@
 DIR = "tests/fixtures"
 
 
-def data_return_function(file_name):
+def data_return_function(input):
     async def function(request):
-        if isinstance(file_name, str):
-            with open(os.path.join(DIR, file_name)) as f:
+        if isinstance(input, str):
+            with open(os.path.join(DIR, input)) as f:
                 return aiohttp.web.json_response(data=json.load(f))
-        elif isinstance(file_name, list):
-            with open(os.path.join(DIR, file_name.pop(0))) as f:
-                return aiohttp.web.json_response(data=json.load(f))
-        return None
+        elif isinstance(input, list):
+            input0 = input.pop(0)
+            if isinstance(input0, str):
+                with open(os.path.join(DIR, input0)) as f:
+                    return aiohttp.web.json_response(data=json.load(f))
+            if issubclass(input0, Exception):
+                raise input0
+        raise RuntimeError("Unexpected input")
 
     return function
 

tests/test_simple_nws.py

@@ -1,7 +1,10 @@
+from unittest.mock import AsyncMock, patch
+
+import aiohttp
 from freezegun import freeze_time
 import pytest
 
-from pynws import NwsError, SimpleNWS
+from pynws import NwsError, SimpleNWS, call_with_retry
 from tests.helpers import setup_app
 
 LATLON = (0, 0)
@@ -61,6 +64,43 @@ async def test_nws_observation(aiohttp_client, mock_urls, observation_json):
     assert observation["iconWeather"][0][1] is None
 
 
+async def test_nws_observation_with_retry(aiohttp_client, mock_urls):
+    # update fails without retry
+    app = setup_app(
+        stations_observations=[aiohttp.web.HTTPBadGateway, "stations_observations.json"]
+    )
+    client = await aiohttp_client(app)
+    nws = SimpleNWS(*LATLON, USERID, client)
+    await nws.set_station(STATION)
+
+    with pytest.raises(aiohttp.ClientResponseError):
+        await nws.update_observation()
+
+    # update succeeds with retry
+    app = setup_app(
+        stations_observations=[aiohttp.web.HTTPBadGateway, "stations_observations.json"]
+    )
+    client = await aiohttp_client(app)
+    nws = SimpleNWS(*LATLON, USERID, client)
+    await nws.set_station(STATION)
+
+    await call_with_retry(nws.update_observation, 0, 5)
+    observation = nws.observation
+    assert observation
+    assert observation["temperature"] == 10
+
+    # no retry for 4xx error
+    app = setup_app(
+        stations_observations=[aiohttp.web.HTTPBadRequest, "stations_observations.json"]
+    )
+    client = await aiohttp_client(app)
+    nws = SimpleNWS(*LATLON, USERID, client)
+
+    await nws.set_station(STATION)
+    with pytest.raises(aiohttp.ClientResponseError):
+        await call_with_retry(nws.update_observation, 0, 5)
+
+
 async def test_nws_observation_units(aiohttp_client, mock_urls):
     app = setup_app(stations_observations="stations_observations_alternate_units.json")
     client = await aiohttp_client(app)
@@ -313,3 +353,46 @@ async def test_nws_alerts_all_zones_second_alert(aiohttp_client, mock_urls):
     assert alerts
     assert new_alerts == alerts
     assert len(alerts) == 2
+
+
+async def test_retries(aiohttp_client, mock_urls):
+    with patch("pynws.simple_nws._is_500_error") as err_mock:
+        # retry all exceptions
+        err_mock.return_value = True
+
+        app = setup_app()
+        client = await aiohttp_client(app)
+        nws = SimpleNWS(*LATLON, USERID, client)
+        await nws.set_station(STATION)
+
+        mock_update = AsyncMock()
+        mock_update.side_effect = [ValueError, None]
+
+        async def mock_wrap(*args, **kwargs):
+            return await mock_update(*args, **kwargs)
+
+        await call_with_retry(mock_wrap, 0, 5)
+
+        assert mock_update.call_count == 2
+
+    mock_update = AsyncMock()
+
+    async def mock_wrap(*args, **kwargs):
+        return await mock_update(*args, **kwargs)
+
+    await call_with_retry(mock_wrap, 0, 5, "", test=None)
+
+    mock_update.assert_called_once_with("", test=None)
+
+    # positional only args
+    with pytest.raises(TypeError):
+        call_with_retry(mock_wrap, interval=0, stop=5)
+
+    mock_update = AsyncMock()
+    mock_update.side_effect = [RuntimeError, None]
+
+    async def mock_wrap(*args, **kwargs):
+        return await mock_update(*args, **kwargs)
+
+    with pytest.raises(RuntimeError):
+        await call_with_retry(mock_wrap, 0, 5)