fix(ws): clear shared websocket on close and harden disconnect cleanup

[jeeftor]

Summary

Fixes all four bugs in the websocket layer that cause the weatherflow_cloud Home Assistant integration to lose wind sensors after a few days and require a full HA restart to reload.

Tracking issue: #141. Also relates to #134 and home-assistant/core#174833.

Bug 1 — broken is_connected guard in close()

close() referenced the bound method self.is_connected (always truthy) instead of calling self.is_connected(). The not-connected early-return guard therefore never fired, so cleanup always proceeded into a dead socket and threw ConnectionClosedOK. Now calls self.is_connected().

Bug 2 — _shared_websocket class-variable leak

close() only cleared the instance attribute self.websocket, never the class-level WeatherFlowWebsocketAPI._shared_websocket. After the server's idle timeout the dead socket stayed referenced, so connect() reused it on reload — which is why the entry couldn't come back up without a full HA restart (only process death cleared the class variable). Now the class reference is cleared on both the early-return and normal close paths, but only when it points at the socket being closed (so a different instance's shared socket is left intact).

Bug 3 — stop_all_listeners leaked unawaited coroutines

stop_all_listeners awaited coroutines sequentially, so the first ConnectionClosedOK aborted the loop and the remaining coroutines were never awaited — producing RuntimeWarning: coroutine 'WeatherFlowWebsocketAPI.send_message_and_wait' was never awaited. It now:

• skips entirely when not connected, and
• gathers with return_exceptions=True so no coroutine is left unawaited, logging ConnectionClosed at debug and unexpected errors at warning.

Bug 4 — No reconnection when the server closes the socket (the stale-sensors symptom)

listen() just exited when the connection dropped and nothing reconnected. Wind data only arrives via websocket, so once the server killed the socket (idle timeout / keepalive ping timeout), wind sensors went stale permanently. Added:

• Subscription tracking: send_message / send_message_and_wait track listen_start / listen_rapid_start messages (and remove on the corresponding stop), so they can be replayed after reconnect.
• Listen supervisor: connect() now starts a supervisor task that wraps listen() in a reconnect loop. On unexpected disconnect, it reconnects with exponential backoff (1s → 60s cap) and replays all active subscriptions on the new connection.
• Shutdown signal: close() sets _shutting_down = True before teardown so the supervisor exits instead of reconnecting.
• Cooperative scheduling: the supervisor yields to the event loop each iteration (asyncio.sleep(0)) so close() can run even when listen() returns instantly (already-closed socket).

Test plan

• Existing suite still green (98 tests)
• 16 new tests covering:
  • stop_all_listeners skips when not connected / no websocket
  • stop_all_listeners no longer leaks coroutines when sends raise ConnectionClosedOK
  • close() clears _shared_websocket on normal close
  • close() clears _shared_websocket on the already-closed (idle timeout) path
  • close() does not clear a shared socket owned by another instance
  • close() calls is_connected() (regression guard for the bound-method bug)
  • end-to-end: after close() clears the dead socket, connect() opens a fresh one (reload scenario)
  • subscription tracking: listen_start adds, listen_stop removes matching entry, other devices unaffected
  • supervisor reconnects after listen() exits
  • supervisor replays subscriptions after reconnect
  • close() prevents reconnection
  • close() clears active subscriptions
  • supervisor exits when close() is called during reconnect backoff
• ruff check, ruff format, ty check, codespell, pyupgrade all pass

Generated with Devin

[devin-ai-integration]

Devin Review found 3 potential issues.

1 flag not posted on this PR by your GitHub settings — view it in Devin Review. (Configure)

[devin-ai-integration]

🟡 Concurrent stop acknowledgements are lost

With multiple stop requests, gather installs competing acknowledgement callbacks concurrently. Bursty replies reach only the last callback, delaying shutdown until the others time out.

Prompt for agents

Rework WeatherFlowWebsocketAPI.stop_all_listeners in weatherflow4py/ws.py so stop requests do not concurrently overwrite the single ACKNOWLEDGEMENT callback used by send_message_and_wait. Preserve the requirement that every created coroutine is awaited or closed when a send fails. A sequential, lazily created request flow is one option; a correlation-aware acknowledgement dispatcher is another. Add a test that delivers several ACK frames back-to-back for multiple devices and verifies every wait completes without timing out.

---

Was this helpful? React with 👍 or 👎 to provide feedback.

[devin-ai-integration]

🟡 Closed sockets leave listeners running

When the socket closes during a callback, close returns without cancelling listen_task. Shutdown can finish while that callback continues using unloaded resources.

Prompt for agents

Make WeatherFlowWebsocketAPI.close clean up listen_task even when is_connected() is false. The early-return path currently clears websocket state but can leave listen() running if the transport closed while an awaited callback is still executing. Cancel and await any unfinished listener with the supplied timeout before returning, while retaining the dead shared-socket cleanup. Add a regression test with a callback blocked on an event and a websocket whose state changes to CLOSED.

---

Was this helpful? React with 👍 or 👎 to provide feedback.

[devin-ai-integration]

🔴 One client disconnects every client

When clients share a connection, one client’s close removes it without tracking remaining owners. Their active listeners then lose weather updates.

Prompt for agents

Define and enforce shared-connection ownership for WeatherFlowWebsocketAPI. connect() deliberately lets multiple instances use _shared_websocket, so close() cannot unconditionally close and clear that connection while another instance still owns it. Track connected owners or avoid sharing connections; ensure closing one instance removes only its subscriptions/listener and closes the transport only for the last owner. Add a test where two instances connect to the same socket, one closes, and the other continues receiving data.

---

Was this helpful? React with 👍 or 👎 to provide feedback.