systembridgeconnector 5.0.0.dev0__tar.gz → 5.0.0.dev2__tar.gz

{systembridgeconnector-5.0.0.dev0 → systembridgeconnector-5.0.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: systembridgeconnector
-Version: 5.0.0.dev0
+Version: 5.0.0.dev2
 Summary: System Bridge Connector
 Home-page: https://github.com/timmo001/system-bridge-connector
 Author: Aidan Timson (Timmo)
@@ -10,10 +10,11 @@ Keywords: system-bridge
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: aiohttp>=3.9.0b0; python_version >= "3.12"
 Requires-Dist: aiohttp>=3.8.5; python_version < "3.12"
+Requires-Dist: aiohttp>=3.9.0b0; python_version >= "3.12"
 Requires-Dist: incremental>=22.10.0
-Requires-Dist: systembridgemodels>=4.0.4
+Requires-Dist: packaging>=24.0
+Requires-Dist: systembridgemodels>=4.1.0
 
 # System Bridge - Connector
 

{systembridgeconnector-5.0.0.dev0 → systembridgeconnector-5.0.0.dev2}/systembridgeconnector/_version.py

@@ -7,5 +7,5 @@ Provides systembridgeconnector version information.
 
 from incremental import Version
 
-__version__ = Version("systembridgeconnector", 5, 0, 0, dev=0)
+__version__ = Version("systembridgeconnector", 5, 0, 0, dev=2)
 __all__ = ["__version__"]

systembridgeconnector-5.0.0.dev2/systembridgeconnector/const.py

@@ -0,0 +1,124 @@
+"""Constants."""
+
+from enum import StrEnum
+
+
+class QueryParameter(StrEnum):
+    """Query Parameter."""
+
+    ALBUM = "album"
+    API_PORT = "apiPort"
+    ARTIST = "artist"
+    AUTOPLAY = "autoplay"
+    BASE = "base"
+    FILENAME = "filename"
+    PATH = "path"
+    TITLE = "title"
+    TOKEN = "token"
+    URL = "url"
+    VOLUME = "volume"
+
+
+class EventKey(StrEnum):
+    """Event Key."""
+
+    APP_ICON = "app_icon"
+    APP_NAME = "app_name"
+    BASE = "base"
+    DATA = "data"
+    DIRECTORIES = "directories"
+    EVENT = "event"
+    FILE = "file"
+    FILENAME = "filename"
+    FILES = "files"
+    ID = "id"
+    KEY = "key"
+    MESSAGE = "message"
+    MODULE = "module"
+    MODULES = "modules"
+    PATH = "path"
+    SETTING = "setting"
+    SUBTYPE = "subtype"
+    TEXT = "text"
+    TIMEOUT = "timeout"
+    TITLE = "title"
+    TOKEN = "token"
+    TYPE = "type"
+    URL = "url"
+    VALUE = "value"
+    VERSION = "version"
+    VERSIONS = "versions"
+
+
+class EventType(StrEnum):
+    """Event Type."""
+
+    APPLICATION_UPDATE = "APPLICATION_UPDATE"
+    APPLICATION_UPDATING = "APPLICATION_UPDATING"
+    DATA_GET = "DATA_GET"
+    DATA_LISTENER_REGISTERED = "DATA_LISTENER_REGISTERED"
+    DATA_LISTENER_UNREGISTERED = "DATA_LISTENER_UNREGISTERED"
+    DATA_UPDATE = "DATA_UPDATE"
+    DIRECTORIES = "DIRECTORIES"
+    ERROR = "ERROR"
+    EXIT_APPLICATION = "EXIT_APPLICATION"
+    FILE = "FILE"
+    FILES = "FILES"
+    GET_DATA = "GET_DATA"
+    GET_DIRECTORIES = "GET_DIRECTORIES"
+    GET_FILE = "GET_FILE"
+    GET_FILES = "GET_FILES"
+    GET_SETTINGS = "GET_SETTINGS"
+    KEYBOARD_KEY_PRESSED = "KEYBOARD_KEY_PRESSED"
+    KEYBOARD_KEYPRESS = "KEYBOARD_KEYPRESS"
+    KEYBOARD_TEXT = "KEYBOARD_TEXT"
+    KEYBOARD_TEXT_SENT = "KEYBOARD_TEXT_SENT"
+    MEDIA_CONTROL = "MEDIA_CONTROL"
+    NOTIFICATION = "NOTIFICATION"
+    NOTIFICATION_SENT = "NOTIFICATION_SENT"
+    OPEN = "OPEN"
+    OPENED = "OPENED"
+    POWER_HIBERNATE = "POWER_HIBERNATE"
+    POWER_HIBERNATING = "POWER_HIBERNATING"
+    POWER_LOCK = "POWER_LOCK"
+    POWER_LOCKING = "POWER_LOCKING"
+    POWER_LOGGINGOUT = "POWER_LOGGINGOUT"
+    POWER_LOGOUT = "POWER_LOGOUT"
+    POWER_RESTART = "POWER_RESTART"
+    POWER_RESTARTING = "POWER_RESTARTING"
+    POWER_SHUTDOWN = "POWER_SHUTDOWN"
+    POWER_SHUTTINGDOWN = "POWER_SHUTTINGDOWN"
+    POWER_SLEEP = "POWER_SLEEP"
+    POWER_SLEEPING = "POWER_SLEEPING"
+    REGISTER_DATA_LISTENER = "REGISTER_DATA_LISTENER"
+    SETTINGS_UPDATED = "SETTINGS_UPDATED"
+    SETTINGS_RESULT = "SETTINGS_RESULT"
+    UNREGISTER_DATA_LISTENER = "UNREGISTER_DATA_LISTENER"
+    UPDATE_SETTINGS = "UPDATE_SETTINGS"
+
+
+class EventSubType(StrEnum):
+    """Event SubType."""
+
+    BAD_TOKEN = "BAD_TOKEN"
+    BAD_DIRECTORY = "BAD_DIRECTORY"
+    BAD_FILE = "BAD_FILE"
+    BAD_JSON = "BAD_JSON"
+    BAD_KEY = "MISSING_KEY"
+    BAD_PATH = "BAD_PATH"
+    BAD_REQUEST = "BAD_REQUEST"
+    INVALID_ACTION = "INVALID_ACTION"
+    LISTENER_ALREADY_REGISTERED = "LISTENER_ALREADY_REGISTERED"
+    LISTENER_NOT_REGISTERED = "LISTENER_NOT_REGISTERED"
+    MISSING_ACTION = "MISSING_ACTION"
+    MISSING_TOKEN = "MISSING_TOKEN"
+    MISSING_BASE = "MISSING_BASE"
+    MISSING_KEY = "MISSING_KEY"
+    MISSING_MODULES = "MISSING_MODULES"
+    MISSING_PATH = "MISSING_PATH"
+    MISSING_PATH_URL = "MISSING_PATH_URL"
+    MISSING_SETTING = "MISSING_SETTING"
+    MISSING_TEXT = "MISSING_TEXT"
+    MISSING_TITLE = "MISSING_TITLE"
+    MISSING_VALUE = "MISSING_VALUE"
+    UNKNOWN_EVENT = "UNKNOWN_EVENT"

{systembridgeconnector-5.0.0.dev0 → systembridgeconnector-5.0.0.dev2}/systembridgeconnector/version.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from aiohttp import ClientSession
-from pkg_resources import parse_version
+from packaging.version import parse
 
 from systembridgemodels.modules.system import System
 
@@ -39,7 +39,7 @@ class Version(Base):
             await self.check_version_2() is None
             and (version := await self.check_version()) is not None
         ):
-            return parse_version(version) >= parse_version(SUPPORTED_VERSION)
+            return parse(version) >= parse(SUPPORTED_VERSION)
         return False
 
     async def check_version_2(self) -> str | None:
@@ -72,7 +72,7 @@ class Version(Base):
             if (
                 system
                 and system.version is not None
-                and parse_version(system.version) >= parse_version("3.0.0")
+                and parse(system.version) >= parse("3.0.0")
             ):
                 return system.version
         except ConnectionErrorException as exception:

{systembridgeconnector-5.0.0.dev0 → systembridgeconnector-5.0.0.dev2}/systembridgeconnector/websocket_client.py

@@ -11,7 +11,7 @@ from uuid import uuid4
 
 import aiohttp
 
-from systembridgemodels.const import MODEL_MAP, MODEL_RESPONSE
+from systembridgemodels.const import MODEL_MAP, Model
 from systembridgemodels.keyboard_key import KeyboardKey
 from systembridgemodels.keyboard_text import KeyboardText
 from systembridgemodels.media_control import MediaControl
@@ -28,51 +28,7 @@ from systembridgemodels.response import Response
 from systembridgemodels.update import Update
 
 from .base import Base
-from .const import (
-    EVENT_DATA,
-    EVENT_ID,
-    EVENT_MESSAGE,
-    EVENT_MODULE,
-    EVENT_SUBTYPE,
-    EVENT_TYPE,
-    SUBTYPE_BAD_TOKEN,
-    SUBTYPE_LISTENER_ALREADY_REGISTERED,
-    TYPE_APPLICATION_UPDATE,
-    TYPE_DATA_GET,
-    TYPE_DATA_LISTENER_REGISTERED,
-    TYPE_DATA_UPDATE,
-    TYPE_DIRECTORIES,
-    TYPE_ERROR,
-    TYPE_EXIT_APPLICATION,
-    TYPE_FILE,
-    TYPE_FILES,
-    TYPE_GET_DATA,
-    TYPE_GET_DIRECTORIES,
-    TYPE_GET_FILE,
-    TYPE_GET_FILES,
-    TYPE_KEYBOARD_KEY_PRESSED,
-    TYPE_KEYBOARD_KEYPRESS,
-    TYPE_KEYBOARD_TEXT,
-    TYPE_KEYBOARD_TEXT_SENT,
-    TYPE_MEDIA_CONTROL,
-    TYPE_NOTIFICATION,
-    TYPE_NOTIFICATION_SENT,
-    TYPE_OPEN,
-    TYPE_OPENED,
-    TYPE_POWER_HIBERNATE,
-    TYPE_POWER_HIBERNATING,
-    TYPE_POWER_LOCK,
-    TYPE_POWER_LOCKING,
-    TYPE_POWER_LOGGINGOUT,
-    TYPE_POWER_LOGOUT,
-    TYPE_POWER_RESTART,
-    TYPE_POWER_RESTARTING,
-    TYPE_POWER_SHUTDOWN,
-    TYPE_POWER_SHUTTINGDOWN,
-    TYPE_POWER_SLEEP,
-    TYPE_POWER_SLEEPING,
-    TYPE_REGISTER_DATA_LISTENER,
-)
+from .const import EventKey, EventSubType, EventType
 from .exceptions import (
     AuthenticationException,
     BadMessageException,
@@ -151,7 +107,7 @@ class WebSocketClient(Base):
                 self._logger.error("Timeout waiting for future: %s", request.id)
                 return Response(
                     id=request.id,
-                    type=TYPE_ERROR,
+                    type=EventType.ERROR,
                     subtype="TIMEOUT",
                     message="Timeout waiting for response",
                     data={},
@@ -209,7 +165,7 @@ class WebSocketClient(Base):
         """Update application."""
         self._logger.info("Updating application")
         return await self._send_message(
-            TYPE_APPLICATION_UPDATE,
+            EventType.APPLICATION_UPDATE,
             request_id,
             asdict(model),
             wait_for_response=False,
@@ -222,7 +178,7 @@ class WebSocketClient(Base):
         """Exit backend."""
         self._logger.info("Exiting backend")
         return await self._send_message(
-            TYPE_EXIT_APPLICATION,
+            EventType.EXIT_APPLICATION,
             request_id,
             {},
             wait_for_response=False,
@@ -247,17 +203,20 @@ class WebSocketClient(Base):
             self._logger.debug("Set new data for: %s", module_name)
             setattr(modules_data, module_name, module)
 
-        await self.listen(
-            callback=handle_module,
-            accept_other_types=False,
+        listener_task = asyncio.create_task(
+            self.listen(
+                callback=handle_module,
+                accept_other_types=False,
+            ),
+            name="Get data WebSocket Listener",
         )
 
         await self._send_message(
-            TYPE_GET_DATA,
+            EventType.GET_DATA,
             request_id,
             asdict(model),
             wait_for_response=True,
-            response_type=TYPE_DATA_GET,
+            response_type=EventType.DATA_GET,
         )
 
         # Wait for all data modules to be set
@@ -272,6 +231,10 @@ class WebSocketClient(Base):
             raise DataMissingException(
                 f"Timeout waiting for data after {timeout} seconds"
             ) from exception
+        finally:
+            self._logger.debug("Cancelling listener task")
+            if not listener_task.done():
+                listener_task.cancel()
 
         return modules_data
 
@@ -282,11 +245,11 @@ class WebSocketClient(Base):
         """Get directories."""
         self._logger.info("Getting directories..")
         response = await self._send_message(
-            TYPE_GET_DIRECTORIES,
+            EventType.GET_DIRECTORIES,
             request_id,
             {},
             wait_for_response=True,
-            response_type=TYPE_DIRECTORIES,
+            response_type=EventType.DIRECTORIES,
         )
 
         return (
@@ -303,11 +266,11 @@ class WebSocketClient(Base):
         """Get files."""
         self._logger.info("Getting files: %s", model)
         response = await self._send_message(
-            TYPE_GET_FILES,
+            EventType.GET_FILES,
             request_id,
             asdict(model),
             wait_for_response=True,
-            response_type=TYPE_FILES,
+            response_type=EventType.FILES,
         )
 
         return (
@@ -330,11 +293,11 @@ class WebSocketClient(Base):
         """Get files."""
         self._logger.info("Getting file: %s", model)
         response = await self._send_message(
-            TYPE_GET_FILE,
+            EventType.GET_FILE,
             request_id,
             asdict(model),
             wait_for_response=True,
-            response_type=TYPE_FILE,
+            response_type=EventType.FILE,
         )
 
         return (
@@ -351,11 +314,11 @@ class WebSocketClient(Base):
         """Register data listener."""
         self._logger.info("Registering data listener: %s", model)
         return await self._send_message(
-            TYPE_REGISTER_DATA_LISTENER,
+            EventType.REGISTER_DATA_LISTENER,
             request_id,
             asdict(model),
             wait_for_response=True,
-            response_type=TYPE_DATA_LISTENER_REGISTERED,
+            response_type=EventType.DATA_LISTENER_REGISTERED,
         )
 
     async def keyboard_keypress(
@@ -366,11 +329,11 @@ class WebSocketClient(Base):
         """Keyboard keypress."""
         self._logger.info("Press key: %s", model)
         return await self._send_message(
-            TYPE_KEYBOARD_KEYPRESS,
+            EventType.KEYBOARD_KEYPRESS,
             request_id,
             asdict(model),
             wait_for_response=True,
-            response_type=TYPE_KEYBOARD_KEY_PRESSED,
+            response_type=EventType.KEYBOARD_KEY_PRESSED,
         )
 
     async def keyboard_text(
@@ -381,11 +344,11 @@ class WebSocketClient(Base):
         """Keyboard keypress."""
         self._logger.info("Enter text: %s", model)
         return await self._send_message(
-            TYPE_KEYBOARD_TEXT,
+            EventType.KEYBOARD_TEXT,
             request_id,
             asdict(model),
             wait_for_response=True,
-            response_type=TYPE_KEYBOARD_TEXT_SENT,
+            response_type=EventType.KEYBOARD_TEXT_SENT,
         )
 
     async def media_control(
@@ -396,7 +359,7 @@ class WebSocketClient(Base):
         """Media control."""
         self._logger.info("Media control: %s", model)
         return await self._send_message(
-            TYPE_MEDIA_CONTROL,
+            EventType.MEDIA_CONTROL,
             request_id,
             asdict(model),
             wait_for_response=False,
@@ -410,11 +373,11 @@ class WebSocketClient(Base):
         """Send notification."""
         self._logger.info("Send notification: %s", model)
         return await self._send_message(
-            TYPE_NOTIFICATION,
+            EventType.NOTIFICATION,
             request_id,
             asdict(model),
             wait_for_response=True,
-            response_type=TYPE_NOTIFICATION_SENT,
+            response_type=EventType.NOTIFICATION_SENT,
         )
 
     async def open_path(
@@ -425,11 +388,11 @@ class WebSocketClient(Base):
         """Open path."""
         self._logger.info("Opening path: %s", model)
         return await self._send_message(
-            TYPE_OPEN,
+            EventType.OPEN,
             request_id,
             asdict(model),
             wait_for_response=True,
-            response_type=TYPE_OPENED,
+            response_type=EventType.OPENED,
         )
 
     async def open_url(
@@ -440,11 +403,11 @@ class WebSocketClient(Base):
         """Open url."""
         self._logger.info("Opening URL: %s", model)
         return await self._send_message(
-            TYPE_OPEN,
+            EventType.OPEN,
             request_id,
             asdict(model),
             wait_for_response=True,
-            response_type=TYPE_OPENED,
+            response_type=EventType.OPENED,
         )
 
     async def power_sleep(
@@ -454,11 +417,11 @@ class WebSocketClient(Base):
         """Power sleep."""
         self._logger.info("Power sleep")
         return await self._send_message(
-            TYPE_POWER_SLEEP,
+            EventType.POWER_SLEEP,
             request_id,
             {},
             wait_for_response=True,
-            response_type=TYPE_POWER_SLEEPING,
+            response_type=EventType.POWER_SLEEPING,
         )
 
     async def power_hibernate(
@@ -468,11 +431,11 @@ class WebSocketClient(Base):
         """Power hibernate."""
         self._logger.info("Power hibernate")
         return await self._send_message(
-            TYPE_POWER_HIBERNATE,
+            EventType.POWER_HIBERNATE,
             request_id,
             {},
             wait_for_response=True,
-            response_type=TYPE_POWER_HIBERNATING,
+            response_type=EventType.POWER_HIBERNATING,
         )
 
     async def power_restart(
@@ -482,11 +445,11 @@ class WebSocketClient(Base):
         """Power restart."""
         self._logger.info("Power restart")
         return await self._send_message(
-            TYPE_POWER_RESTART,
+            EventType.POWER_RESTART,
             request_id,
             {},
             wait_for_response=True,
-            response_type=TYPE_POWER_RESTARTING,
+            response_type=EventType.POWER_RESTARTING,
         )
 
     async def power_shutdown(
@@ -496,11 +459,11 @@ class WebSocketClient(Base):
         """Power shutdown."""
         self._logger.info("Power shutdown")
         return await self._send_message(
-            TYPE_POWER_SHUTDOWN,
+            EventType.POWER_SHUTDOWN,
             request_id,
             {},
             wait_for_response=True,
-            response_type=TYPE_POWER_SHUTTINGDOWN,
+            response_type=EventType.POWER_SHUTTINGDOWN,
         )
 
     async def power_lock(
@@ -510,11 +473,11 @@ class WebSocketClient(Base):
         """Power lock."""
         self._logger.info("Power lock")
         return await self._send_message(
-            TYPE_POWER_LOCK,
+            EventType.POWER_LOCK,
             request_id,
             {},
             wait_for_response=True,
-            response_type=TYPE_POWER_LOCKING,
+            response_type=EventType.POWER_LOCKING,
         )
 
     async def power_logout(
@@ -524,115 +487,158 @@ class WebSocketClient(Base):
         """Power logout."""
         self._logger.info("Power logout")
         return await self._send_message(
-            TYPE_POWER_LOGOUT,
+            EventType.POWER_LOGOUT,
             request_id,
             {},
             wait_for_response=True,
-            response_type=TYPE_POWER_LOGGINGOUT,
+            response_type=EventType.POWER_LOGGINGOUT,
         )
 
     async def listen(
         self,
         callback: Callable[[str, Any], Awaitable[None]] | None = None,
         accept_other_types: bool = False,
+        name: str = "WebSocket Client",
     ) -> None:
         """Listen for messages and map to modules."""
 
         async def _callback_message(message: dict) -> None:
             """Message Callback."""
-            self._logger.debug("New message: %s", message[EVENT_TYPE])
+            self._logger.debug("[%s] New message: %s", name, message[EventKey.TYPE])
 
             if (
-                message.get(EVENT_ID) is not None
-                and (response_tuple := self._responses.get(message[EVENT_ID]))
+                message.get(EventKey.ID) is not None
+                and (response_tuple := self._responses.get(message[EventKey.ID]))
                 is not None
             ):
                 future, response_type = response_tuple
-                if response_type is not None and response_type == message[EVENT_TYPE]:
+                if (
+                    response_type is not None
+                    and response_type == message[EventKey.TYPE]
+                ):
                     response = Response(**message)
 
                     if (
-                        response.type == TYPE_DATA_UPDATE
+                        response.type == EventType.DATA_UPDATE
                         and response.module is not None
-                        and message[EVENT_DATA] is not None
+                        and message[EventKey.DATA] is not None
                     ):
                         # Find model from module
-                        model = MODEL_MAP.get(message[EVENT_MODULE])
-                        if model is None:
+                        model_cls = MODEL_MAP.get(message[EventKey.MODULE])
+                        if model_cls is None:
                             self._logger.warning(
-                                "Unknown model: %s", message[EVENT_MODULE]
+                                "[%s] Unknown model: %s", name, message[EventKey.MODULE]
                             )
                         else:
                             self._logger.debug(
-                                "Mapping data to model: %s", model.__name__
+                                "[%s] Mapping data to model: %s",
+                                name,
+                                model_cls.__name__,
                             )
-                            if isinstance(message[EVENT_DATA], list):
+                            if isinstance(message[EventKey.DATA], list):
                                 response.data = [
-                                    model(**data) for data in message[EVENT_DATA]
+                                    model_cls(**data) for data in message[EventKey.DATA]
                                 ]
                             else:
-                                response.data = model(**message[EVENT_DATA])
+                                response.data = model_cls(**message[EventKey.DATA])
 
-                    self._logger.info("Response: %s", response)
+                    self._logger.info("[%s] Response: %s", name, response)
 
                     try:
                         future.set_result(response)
                     except asyncio.InvalidStateError:
                         self._logger.debug(
-                            "Future already set for response ID: %s",
-                            message[EVENT_ID],
+                            "[%s] Future already set for response ID: %s",
+                            name,
+                            message[EventKey.ID],
                         )
 
-            if message[EVENT_TYPE] == TYPE_ERROR:
-                if message[EVENT_SUBTYPE] == SUBTYPE_LISTENER_ALREADY_REGISTERED:
-                    self._logger.debug(message)
+            if message[EventKey.TYPE] == EventType.ERROR:
+                if (
+                    message[EventKey.SUBTYPE]
+                    == EventSubType.LISTENER_ALREADY_REGISTERED
+                ):
+                    self._logger.debug(
+                        "[%s]: %s",
+                        name,
+                        message,
+                    )
                 elif (
-                    message[EVENT_SUBTYPE] == SUBTYPE_BAD_TOKEN
-                    or message[EVENT_SUBTYPE] == "BAD_API_KEY"
+                    message[EventKey.SUBTYPE] == EventSubType.BAD_TOKEN
+                    or message[EventKey.SUBTYPE] == "BAD_API_KEY"
                 ):
-                    self._logger.error(message)
-                    raise AuthenticationException(message[EVENT_MESSAGE])
+                    self._logger.error(
+                        "[%s]: %s",
+                        name,
+                        message,
+                    )
+                    raise AuthenticationException(message[EventKey.MESSAGE])
                 else:
-                    self._logger.warning("Error message: %s", message)
+                    self._logger.warning(
+                        "[%s]: %s",
+                        name,
+                        message,
+                    )
             elif (
-                message[EVENT_TYPE] == TYPE_DATA_UPDATE
-                and message[EVENT_DATA] is not None
+                message[EventKey.TYPE] == EventType.DATA_UPDATE
+                and message[EventKey.DATA] is not None
             ):
                 self._logger.debug(
-                    "New data for: %s\n%s", message[EVENT_MODULE], message[EVENT_DATA]
+                    "[%s] New data for: %s\n%s",
+                    name,
+                    message[EventKey.MODULE],
+                    message[EventKey.DATA],
                 )
-                model = MODEL_MAP.get(message[EVENT_MODULE])
-                if model is None:
-                    self._logger.warning("Unknown model: %s", message[EVENT_MODULE])
+                model_cls = MODEL_MAP.get(message[EventKey.MODULE])
+                if model_cls is None:
+                    self._logger.warning(
+                        "[%s] Unknown model: %s",
+                        name,
+                        message[EventKey.MODULE],
+                    )
                 elif callback is not None:
                     await callback(
-                        message[EVENT_MODULE],
-                        [model(**data) for data in message[EVENT_DATA]]
-                        if isinstance(message[EVENT_DATA], list)
-                        else model(**message[EVENT_DATA]),
+                        message[EventKey.MODULE],
+                        [model_cls(**data) for data in message[EventKey.DATA]]
+                        if isinstance(message[EventKey.DATA], list)
+                        else model_cls(**message[EventKey.DATA]),
                     )
             else:
-                self._logger.debug("Other message: %s", message[EVENT_TYPE])
+                self._logger.debug(
+                    "[%s] Other message: %s",
+                    name,
+                    message[EventKey.TYPE],
+                )
                 if accept_other_types:
-                    model = MODEL_MAP.get(EVENT_TYPE, MODEL_MAP[MODEL_RESPONSE])
-                    if model is not None and callback is not None:
+                    model_cls = MODEL_MAP.get(
+                        message[EventKey.TYPE],
+                        Model.RESPONSE,
+                    )
+                    if model_cls is not None and callback is not None:
                         await callback(
-                            message[EVENT_TYPE],
-                            model(**message),
+                            message[EventKey.TYPE],
+                            model_cls(**message),
                         )
 
-        await self.listen_for_messages(callback=_callback_message)
+        await self.listen_for_messages(
+            callback=_callback_message,
+            name=name,
+        )
 
     async def listen_for_messages(
         self,
         callback: Callable[[dict[Any, Any]], Awaitable[None]],
+        name: str = "WebSocket Client",
     ) -> None:
         """Listen for messages."""
 
         if not self.connected:
             raise ConnectionClosedException("Connection is closed")
 
-        self._logger.info("Listen for messages")
+        self._logger.info(
+            "[%s] Listen for messages",
+            name,
+        )
         if self._websocket is not None:
             while not self._websocket.closed:
                 message = await self.receive_message()
@@ -662,11 +668,11 @@ class WebSocketClient(Base):
         if message.type == aiohttp.WSMsgType.TEXT:
             message_json = message.json()
 
-            if message_json[EVENT_TYPE] == TYPE_ERROR and (
-                message_json[EVENT_SUBTYPE] == SUBTYPE_BAD_TOKEN
-                or message_json[EVENT_SUBTYPE] == "BAD_API_KEY"
+            if message_json[EventKey.TYPE] == EventType.ERROR and (
+                message_json[EventKey.SUBTYPE] == EventSubType.BAD_TOKEN
+                or message_json[EventKey.SUBTYPE] == "BAD_API_KEY"
             ):
-                raise AuthenticationException(message_json[EVENT_MESSAGE])
+                raise AuthenticationException(message_json[EventKey.MESSAGE])
 
             return message_json
 

{systembridgeconnector-5.0.0.dev0 → systembridgeconnector-5.0.0.dev2}/systembridgeconnector.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: systembridgeconnector
-Version: 5.0.0.dev0
+Version: 5.0.0.dev2
 Summary: System Bridge Connector
 Home-page: https://github.com/timmo001/system-bridge-connector
 Author: Aidan Timson (Timmo)
@@ -10,10 +10,11 @@ Keywords: system-bridge
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: aiohttp>=3.9.0b0; python_version >= "3.12"
 Requires-Dist: aiohttp>=3.8.5; python_version < "3.12"
+Requires-Dist: aiohttp>=3.9.0b0; python_version >= "3.12"
 Requires-Dist: incremental>=22.10.0
-Requires-Dist: systembridgemodels>=4.0.4
+Requires-Dist: packaging>=24.0
+Requires-Dist: systembridgemodels>=4.1.0
 
 # System Bridge - Connector
 

{systembridgeconnector-5.0.0.dev0 → systembridgeconnector-5.0.0.dev2}/systembridgeconnector.egg-info/SOURCES.txt

@@ -17,7 +17,6 @@ systembridgeconnector.egg-info/requires.txt
 systembridgeconnector.egg-info/top_level.txt
 tests/test__version.py
 tests/test_base.py
-tests/test_const.py
 tests/test_exceptions.py
 tests/test_http_client.py
 tests/test_version.py

{systembridgeconnector-5.0.0.dev0 → systembridgeconnector-5.0.0.dev2}/systembridgeconnector.egg-info/requires.txt

@@ -1,5 +1,6 @@
 incremental>=22.10.0
-systembridgemodels>=4.0.4
+packaging>=24.0
+systembridgemodels>=4.1.0
 
 [:python_version < "3.12"]
 aiohttp>=3.8.5

{systembridgeconnector-5.0.0.dev0 → systembridgeconnector-5.0.0.dev2}/tests/test_websocket_client.py

@@ -8,36 +8,23 @@ import aiohttp
 import pytest
 from syrupy.assertion import SnapshotAssertion
 
-from systembridgeconnector.const import (
-    EVENT_MODULES,
-    TYPE_DATA_GET,
-    TYPE_DATA_LISTENER_REGISTERED,
-    TYPE_DIRECTORIES,
-    TYPE_FILE,
-    TYPE_FILES,
-    TYPE_KEYBOARD_KEY_PRESSED,
-    TYPE_KEYBOARD_TEXT_SENT,
-    TYPE_NOTIFICATION_SENT,
-    TYPE_OPENED,
-    TYPE_POWER_HIBERNATING,
-    TYPE_POWER_LOCKING,
-    TYPE_POWER_LOGGINGOUT,
-    TYPE_POWER_RESTARTING,
-    TYPE_POWER_SHUTTINGDOWN,
-    TYPE_POWER_SLEEPING,
-)
+from systembridgeconnector.const import EventKey, EventType
 from systembridgeconnector.exceptions import (
     ConnectionClosedException,
     ConnectionErrorException,
 )
 from systembridgeconnector.websocket_client import WebSocketClient
-from systembridgemodels.const import MODEL_SYSTEM
 from systembridgemodels.keyboard_key import KeyboardKey
 from systembridgemodels.keyboard_text import KeyboardText
 from systembridgemodels.media_control import MediaControl
 from systembridgemodels.media_get_file import MediaGetFile
 from systembridgemodels.media_get_files import MediaGetFiles
-from systembridgemodels.modules import GetData, ModulesData, RegisterDataListener
+from systembridgemodels.modules import (
+    GetData,
+    Module,
+    ModulesData,
+    RegisterDataListener,
+)
 from systembridgemodels.notification import Notification
 from systembridgemodels.open_path import OpenPath
 from systembridgemodels.open_url import OpenUrl
@@ -129,7 +116,7 @@ async def test_timeout(
     ):
         response = await websocket_client.get_data(
             GetData(
-                modules=[MODEL_SYSTEM],
+                modules=[Module.SYSTEM],
             ),
             request_id=REQUEST_ID,
         )
@@ -194,14 +181,14 @@ async def test_get_data(
         ws_client,
         Response(
             id=REQUEST_ID,
-            type=TYPE_DATA_GET,
-            data={EVENT_MODULES: [MODEL_SYSTEM]},
+            type=EventType.DATA_GET,
+            data={EventKey.MODULES: [Module.SYSTEM]},
         ),
     )
     assert websocket_client.connected is True
     response = await websocket_client.get_data(
         GetData(
-            modules=[MODEL_SYSTEM],
+            modules=[Module.SYSTEM],
         ),
         request_id=REQUEST_ID,
     )
@@ -220,7 +207,7 @@ async def test_get_directories(
         ws_client,
         Response(
             id=REQUEST_ID,
-            type=TYPE_DIRECTORIES,
+            type=EventType.DIRECTORIES,
             data=[{"key": "documents", "path": "/documents"}],
         ),
     )
@@ -243,7 +230,7 @@ async def test_get_files(
         ws_client,
         Response(
             id=REQUEST_ID,
-            type=TYPE_FILES,
+            type=EventType.FILES,
             data={
                 "files": [
                     {
@@ -287,7 +274,7 @@ async def test_get_file(
         ws_client,
         Response(
             id=REQUEST_ID,
-            type=TYPE_FILE,
+            type=EventType.FILE,
             data={
                 "name": "test",
                 "path": "path/to",
@@ -326,14 +313,14 @@ async def test_register_data_listener(
         ws_client,
         Response(
             id=REQUEST_ID,
-            type=TYPE_DATA_LISTENER_REGISTERED,
-            data={EVENT_MODULES: [MODEL_SYSTEM]},
+            type=EventType.DATA_LISTENER_REGISTERED,
+            data={EventKey.MODULES: [Module.SYSTEM]},
         ),
     )
     assert websocket_client.connected is True
     response = await websocket_client.register_data_listener(
         RegisterDataListener(
-            modules=[MODEL_SYSTEM],
+            modules=[Module.SYSTEM],
         ),
         request_id=REQUEST_ID,
     )
@@ -352,7 +339,7 @@ async def test_keyboard_keypress(
         ws_client,
         Response(
             id=REQUEST_ID,
-            type=TYPE_KEYBOARD_KEY_PRESSED,
+            type=EventType.KEYBOARD_KEY_PRESSED,
             data={"key": "a"},
         ),
     )
@@ -378,7 +365,7 @@ async def test_keyboard_text(
         ws_client,
         Response(
             id=REQUEST_ID,
-            type=TYPE_KEYBOARD_TEXT_SENT,
+            type=EventType.KEYBOARD_TEXT_SENT,
             data={"text": "test"},
         ),
     )
@@ -430,7 +417,7 @@ async def test_send_notification(
         ws_client,
         Response(
             id=REQUEST_ID,
-            type=TYPE_NOTIFICATION_SENT,
+            type=EventType.NOTIFICATION_SENT,
             data={"title": "test", "message": "test"},
         ),
     )
@@ -457,7 +444,7 @@ async def test_open_path(
         ws_client,
         Response(
             id=REQUEST_ID,
-            type=TYPE_OPENED,
+            type=EventType.OPENED,
             data={"path": "test"},
         ),
     )
@@ -483,7 +470,7 @@ async def test_open_url(
         ws_client,
         Response(
             id=REQUEST_ID,
-            type=TYPE_OPENED,
+            type=EventType.OPENED,
             data={"url": "test"},
         ),
     )
@@ -509,7 +496,7 @@ async def test_power_sleep(
         ws_client,
         Response(
             id=REQUEST_ID,
-            type=TYPE_POWER_SLEEPING,
+            type=EventType.POWER_SLEEPING,
             data={},
         ),
     )
@@ -532,7 +519,7 @@ async def test_power_hibernate(
         ws_client,
         Response(
             id=REQUEST_ID,
-            type=TYPE_POWER_HIBERNATING,
+            type=EventType.POWER_HIBERNATING,
             data={},
         ),
     )
@@ -555,7 +542,7 @@ async def test_power_restart(
         ws_client,
         Response(
             id=REQUEST_ID,
-            type=TYPE_POWER_RESTARTING,
+            type=EventType.POWER_RESTARTING,
             data={},
         ),
     )
@@ -578,7 +565,7 @@ async def test_power_shutdown(
         ws_client,
         Response(
             id=REQUEST_ID,
-            type=TYPE_POWER_SHUTTINGDOWN,
+            type=EventType.POWER_SHUTTINGDOWN,
             data={},
         ),
     )
@@ -601,7 +588,7 @@ async def test_power_lock(
         ws_client,
         Response(
             id=REQUEST_ID,
-            type=TYPE_POWER_LOCKING,
+            type=EventType.POWER_LOCKING,
             data={},
         ),
     )
@@ -624,7 +611,7 @@ async def test_power_logout(
         ws_client,
         Response(
             id=REQUEST_ID,
-            type=TYPE_POWER_LOGGINGOUT,
+            type=EventType.POWER_LOGGINGOUT,
             data={},
         ),
     )

systembridgeconnector-5.0.0.dev0/systembridgeconnector/const.py

@@ -1,107 +0,0 @@
-"""Constants."""
-# Query Parameters
-QUERY_ALBUM = "album"
-QUERY_API_PORT = "apiPort"
-QUERY_ARTIST = "artist"
-QUERY_AUTOPLAY = "autoplay"
-QUERY_BASE = "base"
-QUERY_FILENAME = "filename"
-QUERY_PATH = "path"
-QUERY_TITLE = "title"
-QUERY_TOKEN = "token"
-QUERY_URL = "url"
-QUERY_VOLUME = "volume"
-
-# Event Keys
-EVENT_APP_ICON = "app_icon"
-EVENT_APP_NAME = "app_name"
-EVENT_BASE = "base"
-EVENT_DATA = "data"
-EVENT_DIRECTORIES = "directories"
-EVENT_EVENT = "event"
-EVENT_FILE = "file"
-EVENT_FILENAME = "filename"
-EVENT_FILES = "files"
-EVENT_ID = "id"
-EVENT_KEY = "key"
-EVENT_MESSAGE = "message"
-EVENT_MODULE = "module"
-EVENT_MODULES = "modules"
-EVENT_PATH = "path"
-EVENT_SETTING = "setting"
-EVENT_SUBTYPE = "subtype"
-EVENT_TEXT = "text"
-EVENT_TIMEOUT = "timeout"
-EVENT_TITLE = "title"
-EVENT_TOKEN = "token"
-EVENT_TYPE = "type"
-EVENT_URL = "url"
-EVENT_VALUE = "value"
-EVENT_VERSION = "version"
-EVENT_VERSIONS = "versions"
-
-# Event Types
-SUBTYPE_BAD_TOKEN = "BAD_TOKEN"
-SUBTYPE_BAD_DIRECTORY = "BAD_DIRECTORY"
-SUBTYPE_BAD_FILE = "BAD_FILE"
-SUBTYPE_BAD_JSON = "BAD_JSON"
-SUBTYPE_BAD_KEY = "MISSING_KEY"
-SUBTYPE_BAD_PATH = "BAD_PATH"
-SUBTYPE_BAD_REQUEST = "BAD_REQUEST"
-SUBTYPE_INVALID_ACTION = "INVALID_ACTION"
-SUBTYPE_LISTENER_ALREADY_REGISTERED = "LISTENER_ALREADY_REGISTERED"
-SUBTYPE_LISTENER_NOT_REGISTERED = "LISTENER_NOT_REGISTERED"
-SUBTYPE_MISSING_ACTION = "MISSING_ACTION"
-SUBTYPE_MISSING_TOKEN = "MISSING_TOKEN"
-SUBTYPE_MISSING_BASE = "MISSING_BASE"
-SUBTYPE_MISSING_KEY = "MISSING_KEY"
-SUBTYPE_MISSING_MODULES = "MISSING_MODULES"
-SUBTYPE_MISSING_PATH = "MISSING_PATH"
-SUBTYPE_MISSING_PATH_URL = "MISSING_PATH_URL"
-SUBTYPE_MISSING_SETTING = "MISSING_SETTING"
-SUBTYPE_MISSING_TEXT = "MISSING_TEXT"
-SUBTYPE_MISSING_TITLE = "MISSING_TITLE"
-SUBTYPE_MISSING_VALUE = "MISSING_VALUE"
-SUBTYPE_UNKNOWN_EVENT = "UNKNOWN_EVENT"
-TYPE_APPLICATION_UPDATE = "APPLICATION_UPDATE"
-TYPE_APPLICATION_UPDATING = "APPLICATION_UPDATING"
-TYPE_DATA_GET = "DATA_GET"
-TYPE_DATA_LISTENER_REGISTERED = "DATA_LISTENER_REGISTERED"
-TYPE_DATA_LISTENER_UNREGISTERED = "DATA_LISTENER_UNREGISTERED"
-TYPE_DATA_UPDATE = "DATA_UPDATE"
-TYPE_DIRECTORIES = "DIRECTORIES"
-TYPE_ERROR = "ERROR"
-TYPE_EXIT_APPLICATION = "EXIT_APPLICATION"
-TYPE_FILE = "FILE"
-TYPE_FILES = "FILES"
-TYPE_GET_DATA = "GET_DATA"
-TYPE_GET_DIRECTORIES = "GET_DIRECTORIES"
-TYPE_GET_FILE = "GET_FILE"
-TYPE_GET_FILES = "GET_FILES"
-TYPE_GET_SETTINGS = "GET_SETTINGS"
-TYPE_KEYBOARD_KEY_PRESSED = "KEYBOARD_KEY_PRESSED"
-TYPE_KEYBOARD_KEYPRESS = "KEYBOARD_KEYPRESS"
-TYPE_KEYBOARD_TEXT = "KEYBOARD_TEXT"
-TYPE_KEYBOARD_TEXT_SENT = "KEYBOARD_TEXT_SENT"
-TYPE_MEDIA_CONTROL = "MEDIA_CONTROL"
-TYPE_NOTIFICATION = "NOTIFICATION"
-TYPE_NOTIFICATION_SENT = "NOTIFICATION_SENT"
-TYPE_OPEN = "OPEN"
-TYPE_OPENED = "OPENED"
-TYPE_POWER_HIBERNATE = "POWER_HIBERNATE"
-TYPE_POWER_HIBERNATING = "POWER_HIBERNATING"
-TYPE_POWER_LOCK = "POWER_LOCK"
-TYPE_POWER_LOCKING = "POWER_LOCKING"
-TYPE_POWER_LOGGINGOUT = "POWER_LOGGINGOUT"
-TYPE_POWER_LOGOUT = "POWER_LOGOUT"
-TYPE_POWER_RESTART = "POWER_RESTART"
-TYPE_POWER_RESTARTING = "POWER_RESTARTING"
-TYPE_POWER_SHUTDOWN = "POWER_SHUTDOWN"
-TYPE_POWER_SHUTTINGDOWN = "POWER_SHUTTINGDOWN"
-TYPE_POWER_SLEEP = "POWER_SLEEP"
-TYPE_POWER_SLEEPING = "POWER_SLEEPING"
-TYPE_REGISTER_DATA_LISTENER = "REGISTER_DATA_LISTENER"
-TYPE_SETTINGS_UPDATED = "SETTINGS_UPDATED"
-TYPE_SETTINGS_RESULT = "SETTINGS_RESULT"
-TYPE_UNREGISTER_DATA_LISTENER = "UNREGISTER_DATA_LISTENER"
-TYPE_UPDATE_SETTINGS = "UPDATE_SETTINGS"

systembridgeconnector-5.0.0.dev0/tests/test_const.py

@@ -1,23 +0,0 @@
-"""Test the const module."""
-
-from systembridgeconnector.const import (
-    EVENT_BASE,
-    EVENT_DATA,
-    SUBTYPE_BAD_TOKEN,
-    TYPE_DATA_GET,
-    TYPE_DATA_LISTENER_REGISTERED,
-    TYPE_DATA_LISTENER_UNREGISTERED,
-    TYPE_ERROR,
-)
-
-
-def test_const():
-    """Test the const module."""
-    assert EVENT_BASE == "base"
-    assert EVENT_DATA == "data"
-    assert SUBTYPE_BAD_TOKEN == "BAD_TOKEN"
-    assert TYPE_DATA_GET == "DATA_GET"
-    assert TYPE_DATA_LISTENER_REGISTERED == "DATA_LISTENER_REGISTERED"
-    assert TYPE_DATA_LISTENER_UNREGISTERED == "DATA_LISTENER_UNREGISTERED"
-    assert TYPE_ERROR == "ERROR"
-