fix(ERR-03): narrow retry exception catches to httpx.HTTPError

Replace bare `except Exception` with `except httpx.HTTPError` in both
sync and async session retry loops. Transport-level failures are the
only exceptions that should trigger retries; programming errors now
propagate immediately.

Also fixes FakeResponse lambda signature bug in async session and
updates tests to use httpx.ConnectError instead of bare Exception.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: TKIPisalegacycipher

meraki/session/async_.py

@@ -37,9 +37,7 @@ def __init__(
         # Build headers dict
         headers = self._build_headers()
         # Async user-agent prefix
-        headers["User-Agent"] = f"python-meraki/aio-{self._version} " + validate_user_agent(
-            self._be_geo_id, self._caller
-        )
+        headers["User-Agent"] = f"python-meraki/aio-{self._version} " + validate_user_agent(self._be_geo_id, self._caller)
 
         # Build client config (per D-02: Limits replaces Semaphore, per D-06: proxy passthrough)
         client_kwargs: Dict[str, Any] = {
@@ -128,7 +126,7 @@ async def request(self, metadata: Dict[str, Any], method: str, url: str, **kwarg
                 if self._logger:
                     self._logger.info(f"{method} {abs_url}")
                 response = await self._send_request(method, abs_url, **kwargs)
-            except Exception as e:
+            except httpx.HTTPError as e:
                 if self._logger:
                     self._logger.warning(f"{tag}, {operation} - {e}, retrying in 1 second")
                 await self._sleep(1)
@@ -139,7 +137,7 @@ async def request(self, metadata: Dict[str, Any], method: str, url: str, **kwarg
                         type(
                             "FakeResponse",
                             (),
-                            {"status_code": 503, "reason_phrase": str(e), "json": lambda: {}, "content": b""},
+                            {"status_code": 503, "reason_phrase": str(e), "json": lambda self: {}, "content": b""},
                         )(),
                     )
                 continue

meraki/session/base.py

@@ -4,9 +4,8 @@
 
 import json
 import random
-import urllib.parse
 from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING, Any, Dict, Optional
+from typing import Any, Dict, Optional
 
 from meraki._version import __version__
 from meraki.common import (
@@ -32,12 +31,11 @@
     USE_ITERATOR_FOR_GET_PAGES,
     WAIT_ON_RATE_LIMIT,
 )
+import httpx
+
 from meraki.exceptions import APIError, APIResponseError
 from meraki.response_handler import handle_3xx
 
-if TYPE_CHECKING:
-    import httpx
-
 
 class SessionBase(ABC):
     """Abstract base class providing config storage, URL resolution, retry loop, and status dispatch.
@@ -118,9 +116,7 @@ def __init__(
         self._parameters["use_iterator_for_get_pages"] = self._use_iterator_for_get_pages
 
         if self._logger:
-            self._logger.info(
-                f"Meraki dashboard API session initialized with these parameters: {self._parameters}"
-            )
+            self._logger.info(f"Meraki dashboard API session initialized with these parameters: {self._parameters}")
 
     # ------------------------------------------------------------------
     # Abstract methods (subclass contract)
@@ -145,9 +141,7 @@ def _transport_kwargs(self, kwargs: Dict[str, Any]) -> Dict[str, Any]:
     # Template method: request
     # ------------------------------------------------------------------
 
-    def request(
-        self, metadata: Dict[str, Any], method: str, url: str, **kwargs: Any
-    ) -> Optional["httpx.Response"]:
+    def request(self, metadata: Dict[str, Any], method: str, url: str, **kwargs: Any) -> Optional["httpx.Response"]:
         """Execute an API request with retry loop and status dispatch.
 
         Args:
@@ -185,7 +179,7 @@ def request(
                 if self._logger:
                     self._logger.info(f"{method} {abs_url}")
                 response = self._send_request(method, abs_url, **kwargs)
-            except Exception as e:
+            except httpx.HTTPError as e:
                 if self._logger:
                     self._logger.warning(f"{tag}, {operation} - {e}, retrying in 1 second")
                 self._sleep(1)
@@ -261,9 +255,7 @@ def _handle_success(
             return response
         except (json.decoder.JSONDecodeError, ValueError):
             if self._logger:
-                self._logger.warning(
-                    f"{tag}, {operation} - JSON decode error, retrying in 1 second"
-                )
+                self._logger.warning(f"{tag}, {operation} - JSON decode error, retrying in 1 second")
             return None
 
     def _handle_redirect(self, response: "httpx.Response") -> str:
@@ -298,24 +290,18 @@ def _handle_rate_limit(
             )
 
         if self._logger:
-            self._logger.warning(
-                f"{tag}, {operation} - {status} {reason}, retrying in {wait} seconds"
-            )
+            self._logger.warning(f"{tag}, {operation} - {status} {reason}, retrying in {wait} seconds")
         return wait
 
-    def _handle_server_error(
-        self, response: "httpx.Response", metadata: Dict[str, Any]
-    ) -> None:
+    def _handle_server_error(self, response: "httpx.Response", metadata: Dict[str, Any]) -> None:
         """Handle 5xx server errors. Logs warning before retry."""
         tag = metadata["tags"][0]
         operation = metadata["operation"]
         reason = response.reason_phrase if hasattr(response, "reason_phrase") else ""
         status = response.status_code
 
         if self._logger:
-            self._logger.warning(
-                f"{tag}, {operation} - {status} {reason}, retrying in 1 second"
-            )
+            self._logger.warning(f"{tag}, {operation} - {status} {reason}, retrying in 1 second")
 
     def _handle_client_error(
         self,
@@ -381,9 +367,7 @@ def _retry_with_wait(
         status = response.status_code
 
         if self._logger:
-            self._logger.warning(
-                f"{tag}, {operation} - {status} {reason}, retrying in {wait} seconds"
-            )
+            self._logger.warning(f"{tag}, {operation} - {status} {reason}, retrying in {wait} seconds")
         self._sleep(wait)
         retries -= 1
         if retries == 0:
@@ -416,6 +400,5 @@ def _build_headers(self) -> Dict[str, str]:
         return {
             "Authorization": "Bearer " + self._api_key,
             "Content-Type": "application/json",
-            "User-Agent": f"python-meraki/{self._version} "
-            + validate_user_agent(self._be_geo_id, self._caller),
+            "User-Agent": f"python-meraki/{self._version} " + validate_user_agent(self._be_geo_id, self._caller),
         }

tests/unit/test_aio_rest_session.py

@@ -328,7 +328,7 @@ class TestAsyncConnectionErrors:
     @pytest.mark.asyncio
     async def test_retry_on_exception(self, async_session):
         resp_200 = _mock_aio_response(status_code=200)
-        async_session._client.request = AsyncMock(side_effect=[Exception("Connection refused"), resp_200])
+        async_session._client.request = AsyncMock(side_effect=[httpx.ConnectError("Connection refused"), resp_200])
 
         with patch(SLEEP_PATCH, side_effect=_noop_sleep):
             result = await async_session.request(_metadata(), "GET", "/organizations")
@@ -337,10 +337,10 @@ async def test_retry_on_exception(self, async_session):
     @pytest.mark.asyncio
     async def test_exception_raises_after_max_retries(self, async_session):
         async_session._maximum_retries = 2
-        async_session._client.request = AsyncMock(side_effect=Exception("Connection refused"))
+        async_session._client.request = AsyncMock(side_effect=httpx.ConnectError("Connection refused"))
 
         with patch(SLEEP_PATCH, side_effect=_noop_sleep):
-            with pytest.raises((AsyncAPIError, Exception)):
+            with pytest.raises(APIError):
                 await async_session.request(_metadata(), "GET", "/organizations")
 
 
@@ -602,7 +602,7 @@ async def test_logs_request_url(self, async_session_with_logger):
     @pytest.mark.asyncio
     async def test_logs_warning_on_connection_error(self, async_session_with_logger):
         resp_200 = _mock_aio_response(status_code=200)
-        async_session_with_logger._client.request = AsyncMock(side_effect=[Exception("timeout"), resp_200])
+        async_session_with_logger._client.request = AsyncMock(side_effect=[httpx.ConnectError("timeout"), resp_200])
 
         with patch(SLEEP_PATCH, side_effect=_noop_sleep):
             await async_session_with_logger.request(_metadata(), "GET", "/organizations")