Update python dependencies to latest versions

Includes updates for backward-incomptible websockets library changes
and some linter and type checking fixes.

Author: ChrisRegado

com.chrisregado.googlemeet.sdPlugin/manifest.json

@@ -428,7 +428,7 @@
   "Name": "Google Meet",
   "Icon": "images/plugin_icon",
   "URL": "https://github.com/ChrisRegado/streamdeck-googlemeet",
-  "Version": "1.6.0",
+  "Version": "1.6.1",
   "Category": "Google Meet",
   "CategoryIcon": "images/category_icon",
   "OS": [

streamdeck-plugin/requirements.txt

@@ -1,7 +1,7 @@
 altgraph==0.17.4
 macholib==1.16.3
-packaging==24.1
-pyinstaller==6.11.0
-pyinstaller-hooks-contrib==2024.9
-setuptools==75.3.0
-websockets==13.1
+packaging==25.0
+pyinstaller==6.14.2
+pyinstaller-hooks-contrib==2025.8
+setuptools==80.9.0
+websockets==15.0.1

streamdeck-plugin/src/browser_websocket_server.py

@@ -1,9 +1,12 @@
 import asyncio
 import json
 import logging
-from typing import List, Set
+from typing import List, TYPE_CHECKING, Set
 import websockets
 
+if TYPE_CHECKING:
+    from event_handlers.base_event_handler import EventHandler
+
 
 class BrowserWebsocketServer:
     """
@@ -31,15 +34,15 @@ def __init__(self):
         so we can use them to send outbound messages from this plugin to the
         extension.
         """
-        self._ws_clients: Set[websockets.WebSocketServerProtocol] = set()
+        self._ws_clients: Set[websockets.ServerConnection] = set()
 
         """
         Any EventHandlers registered to receive inbound events from the browser extension.
         """
         self._handlers: List["EventHandler"] = []
 
-    def start(self, hostname: str, port: int) -> None:
-        return websockets.serve(self._message_receive_loop, hostname, port)
+    async def start(self, hostname: str, port: int) -> websockets.Server:
+        return await websockets.serve(self._message_receive_loop, hostname, port)
 
     async def send_to_clients(self, message: str) -> None:
         """
@@ -66,16 +69,16 @@ def register_event_handler(self, handler: "EventHandler") -> None:
     def num_connected_clients(self) -> int:
         return len(self._ws_clients)
 
-    def _register_client(self, ws: websockets.WebSocketServerProtocol) -> None:
+    def _register_client(self, ws: websockets.ServerConnection) -> None:
         self._ws_clients.add(ws)
         self._logger.info(
             (f"{ws.remote_address} has connected to our browser websocket."
              f" We now have {len(self._ws_clients)} active connection(s)."))
 
-    async def _unregister_client(self, ws: websockets.WebSocketServerProtocol) -> None:
+    async def _unregister_client(self, ws: websockets.ServerConnection) -> None:
         try:
             await ws.close()
-        except:
+        except Exception:
             self._logger.exception(
                 "Exception while closing browser webocket connection.")
         if ws in self._ws_clients:
@@ -84,7 +87,7 @@ async def _unregister_client(self, ws: websockets.WebSocketServerProtocol) -> No
             (f"{ws.remote_address} has disconnected from our browser websocket."
              f" We now have {len(self._ws_clients)} active connection(s) remaining."))
 
-    async def _message_receive_loop(self, ws: websockets.WebSocketServerProtocol, uri: str) -> None:
+    async def _message_receive_loop(self, ws: websockets.ServerConnection) -> None:
         """
         Loop of waiting for and processing inbound websocket messages, until the
         connection dies. Each connection will create one of these coroutines.
@@ -93,9 +96,9 @@ async def _message_receive_loop(self, ws: websockets.WebSocketServerProtocol, ur
         try:
             async for message in ws:
                 self._logger.info(
-                    f"Received inbound message from browser extension. Message: {message}")
+                    f"Received inbound message from browser extension. Message: {str(message)}")
                 await self._process_inbound_message(message)
-        except:
+        except Exception:
             self._logger.exception(
                 "BrowserWebsocketServer encountered an exception while waiting for inbound messages.")
         finally:
@@ -105,24 +108,24 @@ async def _message_receive_loop(self, ws: websockets.WebSocketServerProtocol, ur
             for handler in self._handlers:
                 try:
                     await handler.on_all_browsers_disconnected()
-                except:
+                except Exception:
                     self._logger.exception(
                         "Connection mananger received an exception from EventHandler!")
 
-    async def _process_inbound_message(self, message: str) -> None:
+    async def _process_inbound_message(self, message: str | bytes) -> None:
         """
         Process one individual inbound websocket message.
         """
         try:
             parsed_event = json.loads(message)
-        except:
+        except Exception:
             self._logger.exception(
-                f"Failed to parse browser websocket message as JSON. Message: {message}")
+                f"Failed to parse browser websocket message as JSON. Message: {str(message)}")
             return
 
         for handler in self._handlers:
             try:
                 await handler.on_browser_event(parsed_event)
-            except:
+            except Exception:
                 self._logger.exception(
                     "Connection mananger received an exception from EventHandler!")

streamdeck-plugin/src/event_handlers/base_event_handler.py

@@ -1,5 +1,10 @@
 import json
 import logging
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from browser_websocket_server import BrowserWebsocketServer
+    from stream_deck_client import StreamDeckWebsocketClient
 
 
 class EventHandler:
@@ -20,7 +25,7 @@ class EventHandler:
     """
     STREAM_DECK_ACTION = "(invalid)"
     # If set to an action prefix string, allows matching a family of actions sharing a prefix.
-    STREAM_DECK_ACTION_PREFIX = None
+    STREAM_DECK_ACTION_PREFIX: str | None = None
 
     def __init__(self, stream_deck: "StreamDeckWebsocketClient", browser_manager: "BrowserWebsocketServer") -> None:
         self._logger = logging.getLogger(__name__)

streamdeck-plugin/src/event_handlers/base_toggle_event_handler.py

@@ -1,10 +1,14 @@
 import asyncio
 from enum import Enum
 import json
-from typing import List
+from typing import List, TYPE_CHECKING
 
 from event_handlers.base_event_handler import EventHandler
 
+if TYPE_CHECKING:
+    from browser_websocket_server import BrowserWebsocketServer
+    from stream_deck_client import StreamDeckWebsocketClient
+
 
 class SDToggleState(Enum):
     """

streamdeck-plugin/src/event_handlers/open_meet_event_handler.py

@@ -1,4 +1,3 @@
-import asyncio
 import json
 from event_handlers.base_event_handler import EventHandler
 

streamdeck-plugin/src/main.py

@@ -92,8 +92,12 @@ def register_handlers(
 
     register_handlers(stream_deck_client, browser_manager)
 
-    loop = asyncio.get_event_loop()
-    loop.run_until_complete(browser_manager.start(
-        hostname="127.0.0.1", port=BROWSER_WEBSOCKET_PORT))
-    loop.run_until_complete(stream_deck_client.start(
-        port=args.port, register_event=args.register_event, plugin_uuid=args.plugin_uuid))
+    browser_manager_loop = browser_manager.start(
+        hostname="127.0.0.1", port=BROWSER_WEBSOCKET_PORT)
+    stream_deck_loop = stream_deck_client.start(
+        port=args.port, register_event=args.register_event, plugin_uuid=args.plugin_uuid)
+
+    async def websocket_loop():
+        await asyncio.gather(browser_manager_loop, stream_deck_loop)
+
+    asyncio.run(websocket_loop())

streamdeck-plugin/src/stream_deck_client.py

@@ -1,8 +1,11 @@
 import json
 import logging
-from typing import List
+from typing import List, TYPE_CHECKING
 import websockets
 
+if TYPE_CHECKING:
+    from event_handlers.base_event_handler import EventHandler
+
 
 class StreamDeckWebsocketClient:
     """
@@ -26,7 +29,7 @@ def __init__(self):
         """
         Our socket to the Stream Deck desktop software.
         """
-        self._websocket: "WebSocketClientProtocol" = None
+        self._websocket: websockets.ClientConnection | None = None
 
     async def start(self, port: int, register_event: str, plugin_uuid: str) -> None:
         uri = f"ws://127.0.0.1:{port}"
@@ -64,23 +67,23 @@ async def send_outbound_message(self, message: str) -> None:
             f"Sending outbound message to Stream Deck. Message: {message}")
         await self._websocket.send(message)
 
-    async def _message_receive_loop(self, websocket: websockets.WebSocketClientProtocol) -> None:
+    async def _message_receive_loop(self, websocket: websockets.ClientConnection) -> None:
         """
         Loop of waiting for and processing inbound websocket messages, until the
         connection dies.
         """
         async for message in websocket:
             self._logger.info(
-                f"Received inbound message from Stream Deck: {message}")
+                f"Received inbound message from Stream Deck: {str(message)}")
             await self._process_inbound_message(message)
 
-    async def _process_inbound_message(self, message: str) -> None:
+    async def _process_inbound_message(self, message: str | bytes) -> None:
         """
         Process one individual inbound websocket message.
         """
         try:
             parsed_event = json.loads(message)
-        except:
+        except Exception:
             """
             If we're receiving invalid data from the Stream Deck app, our socket
             is in a questionable state... Let the error propagate. If the plugin
@@ -93,6 +96,6 @@ async def _process_inbound_message(self, message: str) -> None:
         for handler in self._handlers:
             try:
                 await handler.on_stream_deck_event(parsed_event)
-            except:
+            except Exception:
                 self._logger.exception(
                     "StreamDeckWebsocketClient received an exception from EventHandler!")

streamdeck-plugin/tests/test_browser_websocket_server.py

@@ -42,7 +42,7 @@ async def test_socket_registration(self):
         server._register_client = MagicMock()
         server._unregister_client = AsyncMock()
 
-        await server._message_receive_loop(mock_websocket, "testUri")
+        await server._message_receive_loop(mock_websocket)
 
         server._register_client.assert_called_with(mock_websocket)
         server._unregister_client.assert_called_with(mock_websocket)
@@ -56,7 +56,7 @@ async def test_sockets_gracefully_closed(self):
         mock_websocket = AsyncMock()
         server._ws_clients = set([mock_websocket])
 
-        await server._message_receive_loop(mock_websocket, "testUri")
+        await server._message_receive_loop(mock_websocket)
 
         mock_websocket.close.assert_called_once()
 
@@ -70,7 +70,7 @@ async def test_browser_disconnected_callback_called(self):
         server.register_event_handler(event_handler)
         mock_websocket = AsyncMock()
 
-        await server._message_receive_loop(mock_websocket, "testUri")
+        await server._message_receive_loop(mock_websocket)
 
         event_handler.on_all_browsers_disconnected.assert_called_with()
 
@@ -86,7 +86,7 @@ async def test_browser_disconnected_callback_not_called(self):
         server.register_event_handler(event_handler)
         server._register_client(mock_websocket_1)
 
-        await server._message_receive_loop(mock_websocket_2, "testUri")
+        await server._message_receive_loop(mock_websocket_2)
 
         event_handler.on_all_browsers_disconnected.assert_not_called()
 
@@ -99,7 +99,7 @@ async def test_socket_messages_read(self):
         mock_websocket.__aiter__.return_value = ["m1", "m2"]
         server._process_inbound_message = AsyncMock()
 
-        await server._message_receive_loop(mock_websocket, "testUri")
+        await server._message_receive_loop(mock_websocket)
 
         mock_websocket.__aiter__.assert_called_with()
         server._process_inbound_message.assert_has_calls(