fix comments

Author: tmunzer-AIDE

src/mistapi/__api_session.py

@@ -1156,8 +1156,10 @@ def _getself(self) -> bool:
                             "enable_two_factor",
                             "two_factor_verified",
                             "no_tracking",
+                            "oauth_google",
                             "password_expiry",
                             "password_modified_time",
+                            "via_sso",
                         ]:
                             setattr(self, key, val)
                     if self._show_cli_notif:

src/mistapi/websockets/location.py

@@ -39,6 +39,8 @@ class BleAssetsEvents(_MistWebsocket):
         Maximum number of reconnect attempts before giving up.
     reconnect_backoff : float, default 2.0
         Base backoff delay in seconds. Doubles after each failed attempt.
+    max_reconnect_backoff : float | None, default None
+        Maximum backoff delay in seconds. If None, backoff grows indefinitely.
     queue_maxsize : int, default 0
         Maximum number of messages buffered in the internal queue for the
         ``receive()`` generator. ``0`` means unbounded. When set,
@@ -121,6 +123,8 @@ class ConnectedClientsEvents(_MistWebsocket):
         Maximum number of reconnect attempts before giving up.
     reconnect_backoff : float, default 2.0
         Base backoff delay in seconds. Doubles after each failed attempt.
+    max_reconnect_backoff : float | None, default None
+        Maximum backoff delay in seconds. If None, backoff grows indefinitely.
     queue_maxsize : int, default 0
         Maximum number of messages buffered in the internal queue for the
         ``receive()`` generator. ``0`` means unbounded. When set,
@@ -203,6 +207,8 @@ class SdkClientsEvents(_MistWebsocket):
         Maximum number of reconnect attempts before giving up.
     reconnect_backoff : float, default 2.0
         Base backoff delay in seconds. Doubles after each failed attempt.
+    max_reconnect_backoff : float | None, default None
+        Maximum backoff delay in seconds. If None, backoff grows indefinitely.
     queue_maxsize : int, default 0
         Maximum number of messages buffered in the internal queue for the
         ``receive()`` generator. ``0`` means unbounded. When set,
@@ -285,6 +291,8 @@ class UnconnectedClientsEvents(_MistWebsocket):
         Maximum number of reconnect attempts before giving up.
     reconnect_backoff : float, default 2.0
         Base backoff delay in seconds. Doubles after each failed attempt.
+    max_reconnect_backoff : float | None, default None
+        Maximum backoff delay in seconds. If None, backoff grows indefinitely.
     queue_maxsize : int, default 0
         Maximum number of messages buffered in the internal queue for the
         ``receive()`` generator. ``0`` means unbounded. When set,
@@ -369,6 +377,8 @@ class DiscoveredBleAssetsEvents(_MistWebsocket):
         Maximum number of reconnect attempts before giving up.
     reconnect_backoff : float, default 2.0
         Base backoff delay in seconds. Doubles after each failed attempt.
+    max_reconnect_backoff : float | None, default None
+        Maximum backoff delay in seconds. If None, backoff grows indefinitely.
     queue_maxsize : int, default 0
         Maximum number of messages buffered in the internal queue for the
         ``receive()`` generator. ``0`` means unbounded. When set,

src/mistapi/websockets/orgs.py

@@ -37,6 +37,8 @@ class InsightsEvents(_MistWebsocket):
         Maximum number of reconnect attempts before giving up.
     reconnect_backoff : float, default 2.0
         Base backoff delay in seconds. Doubles after each failed attempt.
+    max_reconnect_backoff : float | None, default None
+        Maximum backoff delay in seconds. If None, backoff grows indefinitely.
     queue_maxsize : int, default 0
         Maximum number of messages buffered in the internal queue for the
         ``receive()`` generator. ``0`` means unbounded. When set,
@@ -115,6 +117,8 @@ class MxEdgesStatsEvents(_MistWebsocket):
         Maximum number of reconnect attempts before giving up.
     reconnect_backoff : float, default 2.0
         Base backoff delay in seconds. Doubles after each failed attempt.
+    max_reconnect_backoff : float | None, default None
+        Maximum backoff delay in seconds. If None, backoff grows indefinitely.
     queue_maxsize : int, default 0
         Maximum number of messages buffered in the internal queue for the
         ``receive()`` generator. ``0`` means unbounded. When set,
@@ -193,6 +197,8 @@ class MxEdgesEvents(_MistWebsocket):
         Maximum number of reconnect attempts before giving up.
     reconnect_backoff : float, default 2.0
         Base backoff delay in seconds. Doubles after each failed attempt.
+    max_reconnect_backoff : float | None, default None
+        Maximum backoff delay in seconds. If None, backoff grows indefinitely.
     queue_maxsize : int, default 0
         Maximum number of messages buffered in the internal queue for the
         ``receive()`` generator. ``0`` means unbounded. When set,

src/mistapi/websockets/session.py

@@ -46,6 +46,8 @@ class SessionWithUrl(_MistWebsocket):
         Maximum number of reconnect attempts before giving up.
     reconnect_backoff : float, default 2.0
         Base backoff delay in seconds. Doubles after each failed attempt.
+    max_reconnect_backoff : float | None, default None
+        Maximum backoff delay in seconds. If None, backoff grows indefinitely.
     queue_maxsize : int, default 0
         Maximum number of messages buffered in the internal queue for the
         ``receive()`` generator. ``0`` means unbounded. When set,

src/mistapi/websockets/sites.py

@@ -37,6 +37,8 @@ class ClientsStatsEvents(_MistWebsocket):
         Maximum number of reconnect attempts before giving up.
     reconnect_backoff : float, default 2.0
         Base backoff delay in seconds. Doubles after each failed attempt.
+    max_reconnect_backoff : float | None, default None
+        Maximum backoff delay in seconds. If None, backoff grows indefinitely.
     queue_maxsize : int, default 0
         Maximum number of messages buffered in the internal queue for the
         ``receive()`` generator. ``0`` means unbounded. When set,
@@ -124,6 +126,8 @@ class DeviceCmdEvents(_MistWebsocket):
         Maximum number of reconnect attempts before giving up.
     reconnect_backoff : float, default 2.0
         Base backoff delay in seconds. Doubles after each failed attempt.
+    max_reconnect_backoff : float | None, default None
+        Maximum backoff delay in seconds. If None, backoff grows indefinitely.
     queue_maxsize : int, default 0
         Maximum number of messages buffered in the internal queue for the
         ``receive()`` generator. ``0`` means unbounded. When set,
@@ -206,6 +210,8 @@ class DeviceStatsEvents(_MistWebsocket):
         Maximum number of reconnect attempts before giving up.
     reconnect_backoff : float, default 2.0
         Base backoff delay in seconds. Doubles after each failed attempt.
+    max_reconnect_backoff : float | None, default None
+        Maximum backoff delay in seconds. If None, backoff grows indefinitely.
     queue_maxsize : int, default 0
         Maximum number of messages buffered in the internal queue for the
         ``receive()`` generator. ``0`` means unbounded. When set,
@@ -285,6 +291,8 @@ class DeviceEvents(_MistWebsocket):
         Maximum number of reconnect attempts before giving up.
     reconnect_backoff : float, default 2.0
         Base backoff delay in seconds. Doubles after each failed attempt.
+    max_reconnect_backoff : float | None, default None
+        Maximum backoff delay in seconds. If None, backoff grows indefinitely.
     queue_maxsize : int, default 0
         Maximum number of messages buffered in the internal queue for the
         ``receive()`` generator. ``0`` means unbounded. When set,
@@ -364,6 +372,8 @@ class MxEdgesStatsEvents(_MistWebsocket):
         Maximum number of reconnect attempts before giving up.
     reconnect_backoff : float, default 2.0
         Base backoff delay in seconds. Doubles after each failed attempt.
+    max_reconnect_backoff : float | None, default None
+        Maximum backoff delay in seconds. If None, backoff grows indefinitely.
     queue_maxsize : int, default 0
         Maximum number of messages buffered in the internal queue for the
         ``receive()`` generator. ``0`` means unbounded. When set,
@@ -443,6 +453,8 @@ class MxEdgesEvents(_MistWebsocket):
         Maximum number of reconnect attempts before giving up.
     reconnect_backoff : float, default 2.0
         Base backoff delay in seconds. Doubles after each failed attempt.
+    max_reconnect_backoff : float | None, default None
+        Maximum backoff delay in seconds. If None, backoff grows indefinitely.
     queue_maxsize : int, default 0
         Maximum number of messages buffered in the internal queue for the
         ``receive()`` generator. ``0`` means unbounded. When set,
@@ -522,6 +534,8 @@ class PcapEvents(_MistWebsocket):
         Maximum number of reconnect attempts before giving up.
     reconnect_backoff : float, default 2.0
         Base backoff delay in seconds. Doubles after each failed attempt.
+    max_reconnect_backoff : float | None, default None
+        Maximum backoff delay in seconds. If None, backoff grows indefinitely.
     queue_maxsize : int, default 0
         Maximum number of messages buffered in the internal queue for the
         ``receive()`` generator. ``0`` means unbounded. When set,

tests/unit/test_api_session.py

@@ -252,6 +252,110 @@ def test_authentication_status_authenticated(self, authenticated_session) -> Non
         assert authenticated_session.get_authentication_status()
 
 
+class TestPasswordClearingAfterLogin:
+    """Test that _password is cleared after successful login"""
+
+    def test_password_cleared_after_successful_login(self, isolated_session) -> None:
+        """_process_login sets _password to None after a 200 response from /api/v1/login"""
+        # Arrange
+        isolated_session._cloud_uri = "api.mist.com"
+        isolated_session.email = "test@example.com"
+        isolated_session._password = "secret_password"
+
+        mock_session = Mock()
+        mock_resp = Mock()
+        mock_resp.status_code = 200
+        mock_session.post.return_value = mock_resp
+
+        with patch.object(isolated_session, "_new_session", return_value=mock_session):
+            # Act
+            error = isolated_session._process_login(retry=False)
+
+            # Assert
+            assert error is None
+            assert isolated_session._password is None
+
+    def test_password_cleared_after_failed_login(self, isolated_session) -> None:
+        """_process_login also clears _password on failure (existing behaviour)"""
+        # Arrange
+        isolated_session._cloud_uri = "api.mist.com"
+        isolated_session.email = "test@example.com"
+        isolated_session._password = "wrong_password"
+
+        mock_session = Mock()
+        mock_resp = Mock()
+        mock_resp.status_code = 401
+        mock_resp.json.return_value = {"detail": "invalid credentials"}
+        mock_session.post.return_value = mock_resp
+
+        with patch.object(isolated_session, "_new_session", return_value=mock_session):
+            # Act
+            isolated_session._process_login(retry=False)
+
+            # Assert
+            assert isolated_session._password is None
+
+    def test_two_factor_succeeds_after_password_cleared(self, isolated_session) -> None:
+        """
+        login_with_return with two_factor still succeeds after _process_login
+        clears the password, because _two_factor_authentication only sends the
+        2FA code (not the password) to /api/v1/login/two_factor.
+        """
+        # Arrange
+        isolated_session._cloud_uri = "api.mist.com"
+        isolated_session.email = "test@example.com"
+        isolated_session._password = "secret_password"
+
+        # Mock _new_session
+        mock_session = Mock()
+        isolated_session._session = mock_session
+
+        # _process_login succeeds (clears password)
+        login_resp = Mock()
+        login_resp.status_code = 200
+
+        # _two_factor_authentication succeeds
+        two_factor_resp = Mock()
+        two_factor_resp.status_code = 200
+
+        mock_session.post.side_effect = [login_resp, two_factor_resp]
+
+        # mist_get for /api/v1/self after auth
+        mock_self_resp = Mock()
+        mock_self_resp.status_code = 200
+        mock_self_resp.data = {
+            "id": "user-123",
+            "email": "test@example.com",
+            "first_name": "Test",
+            "last_name": "User",
+            "privileges": [],
+            "two_factor_required": False,
+            "two_factor_passed": True,
+            "via_sso": False,
+            "tags": [],
+        }
+
+        with patch.object(isolated_session, "_new_session", return_value=mock_session):
+            with patch.object(
+                isolated_session, "mist_get", return_value=mock_self_resp
+            ):
+                # Act
+                result = isolated_session.login_with_return(
+                    email="test@example.com",
+                    password="secret_password",
+                    two_factor="123456",
+                )
+
+                # Assert – password was cleared by _process_login
+                assert isolated_session._password is None
+                # Assert – 2FA POST was sent to the correct endpoint without password
+                second_post_call = mock_session.post.call_args_list[1]
+                assert "/api/v1/login/two_factor" in second_post_call.args[0]
+                assert second_post_call.kwargs["json"] == {"two_factor": "123456"}
+                # Assert – overall auth succeeded
+                assert result["authenticated"] is True
+
+
 class TestPrivilegeManagement:
     """Test privilege-related functionality"""
 

tests/unit/test_websocket_client.py

@@ -729,6 +729,18 @@ def test_negative_queue_maxsize_raises(self, mock_session) -> None:
         with pytest.raises(ValueError, match="queue_maxsize must be >= 0"):
             _MistWebsocket(mock_session, channels=["/ch"], queue_maxsize=-1)
 
+    def test_negative_max_reconnect_backoff_raises(self, mock_session) -> None:
+        with pytest.raises(ValueError, match="max_reconnect_backoff must be > 0"):
+            _MistWebsocket(mock_session, channels=["/ch"], max_reconnect_backoff=-1.0)
+
+    def test_zero_max_reconnect_backoff_raises(self, mock_session) -> None:
+        with pytest.raises(ValueError, match="max_reconnect_backoff must be > 0"):
+            _MistWebsocket(mock_session, channels=["/ch"], max_reconnect_backoff=0)
+
+    def test_max_reconnect_backoff_none_allowed(self, mock_session) -> None:
+        client = _MistWebsocket(mock_session, channels=["/ch"], max_reconnect_backoff=None)
+        assert client._max_reconnect_backoff is None
+
 
 # ---------------------------------------------------------------------------
 # Public WebSocket channel classes
@@ -987,6 +999,102 @@ def test_no_reconnect_when_disabled(self, mock_session) -> None:
         # run_forever called exactly once, no retry
         mock_ws.run_forever.assert_called_once()
 
+    def test_unlimited_attempts_when_max_is_zero(self, mock_session) -> None:
+        """max_reconnect_attempts=0 means unlimited: loop should not stop on its own."""
+        client = self._make_client(mock_session, max_reconnect_attempts=0)
+        call_count = 0
+        target_calls = 8  # well above any hardcoded limit
+
+        def fake_run_forever(**kwargs):
+            nonlocal call_count
+            call_count += 1
+            if call_count >= target_calls:
+                client._user_disconnect.set()  # stop the loop
+            client._handle_close(client._ws, 1006, "drop")
+
+        mock_ws = Mock()
+        mock_ws.run_forever.side_effect = fake_run_forever
+        with patch.object(client, "_create_ws_app", return_value=mock_ws):
+            client._ws = mock_ws
+            client._run_forever_safe()
+
+        assert call_count == target_calls
+
+    def test_delay_capped_by_max_reconnect_backoff(self, mock_session) -> None:
+        """When max_reconnect_backoff is set, the backoff delay never exceeds it."""
+        cap = 0.05
+        client = self._make_client(
+            mock_session,
+            max_reconnect_attempts=5,
+            reconnect_backoff=0.01,
+            max_reconnect_backoff=cap,
+        )
+        observed_delays: list[float] = []
+
+        original_wait = client._user_disconnect.wait
+
+        def capture_delay(timeout=None):
+            if timeout is not None:
+                observed_delays.append(timeout)
+            return original_wait(timeout=0)  # don't actually sleep
+
+        def fake_run_forever(**kwargs):
+            client._handle_close(client._ws, 1006, "drop")
+
+        mock_ws = Mock()
+        mock_ws.run_forever.side_effect = fake_run_forever
+        with (
+            patch.object(client, "_create_ws_app", return_value=mock_ws),
+            patch.object(client._user_disconnect, "wait", side_effect=capture_delay),
+        ):
+            client._ws = mock_ws
+            client._run_forever_safe()
+
+        # Should have recorded a delay for each reconnect attempt
+        assert len(observed_delays) > 0
+        # Every observed delay must be <= cap
+        for delay in observed_delays:
+            assert delay <= cap, f"delay {delay} exceeds cap {cap}"
+        # Without the cap, later delays would grow via exponential backoff
+        # (e.g., 0.01, 0.02, 0.04, 0.08, 0.16). Verify the cap was actually
+        # needed by checking that at least one uncapped delay would exceed it.
+        uncapped = [0.01 * (2 ** i) for i in range(len(observed_delays))]
+        assert any(d > cap for d in uncapped), "cap was never exercised"
+
+    def test_delay_uncapped_when_max_reconnect_backoff_is_none(self, mock_session) -> None:
+        """Without max_reconnect_backoff, delays grow without bound."""
+        client = self._make_client(
+            mock_session,
+            max_reconnect_attempts=4,
+            reconnect_backoff=0.01,
+            max_reconnect_backoff=None,
+        )
+        observed_delays: list[float] = []
+
+        original_wait = client._user_disconnect.wait
+
+        def capture_delay(timeout=None):
+            if timeout is not None:
+                observed_delays.append(timeout)
+            return original_wait(timeout=0)
+
+        def fake_run_forever(**kwargs):
+            client._handle_close(client._ws, 1006, "drop")
+
+        mock_ws = Mock()
+        mock_ws.run_forever.side_effect = fake_run_forever
+        with (
+            patch.object(client, "_create_ws_app", return_value=mock_ws),
+            patch.object(client._user_disconnect, "wait", side_effect=capture_delay),
+        ):
+            client._ws = mock_ws
+            client._run_forever_safe()
+
+        assert len(observed_delays) >= 2
+        # Each delay should be double the previous (exponential backoff)
+        for i in range(1, len(observed_delays)):
+            assert observed_delays[i] == pytest.approx(observed_delays[i - 1] * 2)
+
 
 # ---------------------------------------------------------------------------
 # Callback exception safety