python-swidget 1.2.4__tar.gz → 1.3.0__tar.gz

{python_swidget-1.2.4 → python_swidget-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: python-swidget
-Version: 1.2.4
+Version: 1.3.0
 Summary: Python API for Swidget smart devices
 Home-page: https://github.com/swidget/python-swidget
 License: GPL-3.0-or-later
@@ -13,6 +13,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Provides-Extra: docs
 Requires-Dist: aiohttp (>=3.8.1)
 Requires-Dist: anyio

{python_swidget-1.2.4 → python_swidget-1.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-swidget"
-version = "1.2.4"
+version = "1.3.0"
 description = "Python API for Swidget smart devices"
 license = "GPL-3.0-or-later"
 authors = ["Swidget"]

{python_swidget-1.2.4 → python_swidget-1.3.0}/swidget/__init__.py

@@ -19,6 +19,7 @@ from swidget.exceptions import SwidgetException
 from swidget.provision import provision_wifi
 from swidget.swidgetdevice import (
     DeviceType,
+    InsertType,
     SwidgetAssembly,
     SwidgetComponent,
     SwidgetDevice,
@@ -38,6 +39,7 @@ __all__ = [
     "SwidgetDiscoveredDevice",
     "SwidgetException",
     "DeviceType",
+    "InsertType",
     "SwidgetAssembly",
     "SwidgetDevice",
     "SwidgetComponent",

{python_swidget-1.2.4 → python_swidget-1.3.0}/swidget/discovery.py

@@ -59,7 +59,7 @@ class SwidgetProtocol(ssdp.SimpleServiceDiscoveryProtocol):
                 insert_type=insert_type,
             )
             _LOGGER.debug(
-                f"Swidget device '{friendly_name}' at {ip_address}. {device_type}/{insert_type}"
+                f"Discovered Swidget device via SSDP: '{friendly_name}' at {ip_address} Type:{device_type}/{insert_type}"
             )
 
 
@@ -108,9 +108,8 @@ async def discover_single(
 
     _LOGGER.debug(f"Creating new device class of type: {device_type}")
     device_class = _get_device_class(device_type)
-    _LOGGER.debug(f"{device_class}")
+    _LOGGER.debug(f"{device_class} created")
     dev = device_class(host, token_name, password, use_https, use_websockets)
-    await dev.start()
     return dev
 
 

{python_swidget-1.2.4 → python_swidget-1.3.0}/swidget/swidgetdevice.py

@@ -115,10 +115,10 @@ class SwidgetDevice:
     async def start(self) -> None:
         """Start the websocket."""
         _LOGGER.debug("SwidgetDevice.start()")
-        if self.use_websockets:
+        if self.use_websockets and not self.connected:
             _LOGGER.debug("Calling self._websocket.connect()")
             await self._websocket.connect()
-        _LOGGER.debug("Calling self.update() ")
+        _LOGGER.debug("Calling self.update()")
         await self.update()
 
     async def stop(self) -> bool:
@@ -143,18 +143,18 @@ class SwidgetDevice:
         """Wrapper for the stop() function."""
         await self.stop()
 
-    def add_event_callback(self, callback: Callable[[Any], Any]):
+    def add_event_callback(self, callback: Callable[[Any], Any]) -> bool:
         """Register a function to be called when a new websocket message is recieved."""
         for c in self._subscribers:
             if c == callback:
-                _LOGGER.warn(
+                _LOGGER.warning(
                     "Callback has already been added, not adding the same callback function again"
                 )
                 return False
         self._subscribers.append(callback)
         return True
 
-    def remove_event_callback(self, callback: Callable[[Any], Any]):
+    def remove_event_callback(self, callback: Callable[[Any], Any]) -> bool:
         """Remove a registered callback function."""
         if callback in self._subscribers:
             self._subscribers.remove(callback)
@@ -181,7 +181,7 @@ class SwidgetDevice:
             )
         await self.signal_callbacks(message)
 
-    async def signal_callbacks(self, message):
+    async def signal_callbacks(self, message) -> None:
         """Call any available registered callback functions."""
         _LOGGER.debug("SwidgetDevice.signal_callsbacks() called")
         for callback in self._subscribers:
@@ -190,20 +190,14 @@ class SwidgetDevice:
     async def get_device_config(self) -> Any:
         """Get the config of the device."""
         _LOGGER.debug("SwidgetDevice.get_device_config() called")
-        if self.use_websockets:
-            _LOGGER.debug(
-                "In websocket mode. Sending get_summary() command over websocket"
-            )
-            raise NotImplementedError
-        else:
-            _LOGGER.debug("In http mode. Sending get_summary() command over http")
-            async with self._session.get(
-                url=f"{self.uri_scheme}://{self.ip_address}/api/v1/device_config",
-                ssl=False,
-            ) as response:
-                config = await response.json()
-            self.device_config = DeviceConfiguration(config)
-            self._last_update = int(time.time())
+        _LOGGER.debug("Sending get_summary() command over http")
+        async with self._session.get(
+            url=f"{self.uri_scheme}://{self.ip_address}/api/v1/device_config",
+            ssl=False,
+        ) as response:
+            config = await response.json()
+        self.device_config = DeviceConfiguration(config)
+        self._last_update = int(time.time())
 
     async def get_summary(self) -> None:
         """Get a summary of the device over HTTP."""
@@ -325,7 +319,7 @@ class SwidgetDevice:
         _LOGGER.debug("SwidgetDevice.send_command() called")
         data = {assembly: {"components": {component: {function: command}}}}
         _LOGGER.debug(f"Command to send: {data}")
-        if self.use_websockets:
+        if self.use_websockets and self.connected is True:
             _LOGGER.debug("In websocket mode. Sending command over websocket")
             command_data = json.dumps(
                 {"type": "command", "request_id": "command", "payload": data}
@@ -653,12 +647,12 @@ class SwidgetDevice:
         """Return  True if the device is dimmable."""
         return self.is_dimmer
 
-    @property  # type: ignore
+    @property
     def friendly_name(self) -> str:
         """Return a friendly description of the device."""
         return self._friendly_name
 
-    @property  # type: ignore
+    @property
     def is_on(self) -> bool:
         """Return whether device is on."""
         _LOGGER.debug("SwidgetDevice.is_on called")
@@ -703,7 +697,7 @@ class SwidgetDevice:
             command={"state": "off"},
         )
 
-    @property  # type: ignore
+    @property
     def usb_is_on(self) -> bool:
         """Return whether USB is on."""
         _LOGGER.debug("SwidgetDevice.usb_is_on called")

{python_swidget-1.2.4 → python_swidget-1.3.0}/swidget/swidgetdimmer.py

@@ -25,7 +25,7 @@ class SwidgetDimmer(SwidgetDevice):
             use_https=use_https,
             use_websockets=use_websockets,
         )
-        self._device_type = DeviceType.Dimmer
+        self.device_type = DeviceType.Dimmer
 
     @property  # type: ignore
     def brightness(self) -> int:

python_swidget-1.3.0/swidget/websocket.py

@@ -0,0 +1,207 @@
+"""Module to handle websocket connections to Swidget devices."""
+import asyncio
+import logging
+import socket
+from typing import Any, Awaitable, Callable, Union
+
+import aiohttp
+from aiohttp import (
+    ClientConnectionError,
+    ClientWebSocketResponse,
+    WSMsgType,
+    WSServerHandshakeError,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class SwidgetWebsocket:
+    """A websocket connection to a Swidget Device."""
+
+    def __init__(
+        self,
+        host: str,
+        token_name: str,
+        secret_key: str,
+        callback: Union[Callable[[Any], None], Callable[[Any], Awaitable[None]]],
+        session: aiohttp.ClientSession | None = None,
+        use_security: bool = True,
+        retry_interval: int = 30,  # Initial retry interval in seconds
+        max_retries: int = 200,  # Maximum number of reconnection attempts
+    ):
+        """Initialize the SwidgetWebsocket.
+
+        Args:
+            host: The hostname or IP address of the Swidget device.
+            token_name: The name of the authentication token.
+            secret_key: The secret key for authentication.
+            callback: A callable that will be called with received messages.
+            session: An optional aiohttp.ClientSession to use.
+            use_security: Whether to use wss:// (True) or ws:// (False).
+            retry_interval: Initial interval for reconnection attempts.
+            max_retries: Maximum number of reconnection attempts.
+        """
+        self.host = host
+        self.token_name = token_name or "x-secret-key"
+        self.secret_key = secret_key or ""
+        self.session = session or aiohttp.ClientSession()
+        self.use_security = use_security
+        self.callback = callback
+        self.retry_interval = retry_interval
+        self.max_retries = max_retries
+        self.retry_count = 0
+        self._verify_ssl = False
+        self.uri = self._get_uri()
+
+        # self._client= None
+        self.is_running = True
+        self._closing = False
+        self._client: ClientWebSocketResponse | None = None
+        self._receiver_task: asyncio.Task | None = None
+        self._closing = False
+
+    def _get_uri(self) -> str:
+        """Generate the websocket URI."""
+        protocol = "wss" if self.use_security else "ws"
+        return (
+            f"{protocol}://{self.host}/api/v1/sock?{self.token_name}={self.secret_key}"
+        )
+
+    async def connect(self) -> None:
+        """Connect to the websocket server."""
+        _LOGGER.debug("websocket.connect() called")
+
+        if self.connected:
+            _LOGGER.debug("Websocket already connected")
+            return
+
+        if self._client is not None:
+            raise ConnectionError("Already connected")
+
+        if not self.session:
+            raise ConnectionError("No aiohttp session available")
+
+        headers = {"Connection": "Upgrade", self.token_name: self.secret_key}
+
+        try:
+            _LOGGER.debug(f"Trying to connect to {self.host}")
+            self._client = await self.session.ws_connect(
+                url=self.uri,
+                headers=headers,
+                verify_ssl=self._verify_ssl,
+                heartbeat=30,
+            )
+            self.retry_count = 0
+            _LOGGER.debug("Websocket now connected")
+        except (ClientConnectionError, WSServerHandshakeError) as e:
+            _LOGGER.error(f"Error connecting to websocket: {e}")
+            self._client = None
+        except socket.gaierror as e:
+            _LOGGER.error(f"Error resolving host: {e}")
+            self._client = None
+        except Exception as e:
+            _LOGGER.error(f"An unexpected error occurred: {e}")
+            self._client = None
+
+    async def send_str(self, message: str) -> None:
+        """Send a string message through the websocket with retry attempts."""
+        _LOGGER.debug("websocket.send_str() called")
+        max_send_retries = 3
+        for attempt in range(max_send_retries):
+            try:
+                if self._client is not None:
+                    await self._client.send_str(message)
+                    return
+                else:
+                    _LOGGER.warning("Websocket is not connected, not sending")
+                    return
+            except Exception as e:
+                _LOGGER.warning(
+                    f"Error sending message, attempt {attempt}/{max_send_retries}: {e}"
+                )
+                if attempt < max_send_retries - 1:
+                    await asyncio.sleep(5**attempt)
+                else:
+                    _LOGGER.error(
+                        f"Failed to send message after {max_send_retries} attempts."
+                    )
+
+    async def receive(self):
+        """Receive a message from the WebSocket server."""
+        _LOGGER.debug("websocket.receive() called")
+        try:
+            if self._client is not None:
+                message = await self._client.receive()
+                if message.type == WSMsgType.TEXT:
+                    message_data = message.json()
+                    _LOGGER.debug(f"[{self.host}] Received message: {message_data}")
+                    return message_data
+                elif message.type == WSMsgType.CLOSED:
+                    _LOGGER.error("Websocket client is closed")
+                    self._client = None
+                elif message.type == WSMsgType.ERROR:
+                    _LOGGER.error("WebSocket error.")
+                    self._client = None
+        except Exception as e:
+            _LOGGER.error(f"Error receiving message: {e}")
+
+    async def close(self):
+        """Close the WebSocket connection."""
+        _LOGGER.debug("websocket.close() called")
+        self.is_running = False
+        self._closing = True
+        if self._client is not None:
+            await self._client.close()
+        self._client = None
+        if self.session and not self.session.closed:
+            await self.session.close()
+
+    async def reconnect(self):
+        """Reconnect to the WebSocket server after a delay."""
+        _LOGGER.debug("websocket.reconnect() called")
+        if self.max_retries is not None and self.retry_count >= self.max_retries:
+            _LOGGER.warning("Max retries reached. Stopping reconnect attempts.")
+            self.is_running = False
+            return
+
+        self.retry_count += 1
+        delay = self.retry_interval * (2 ** (self.retry_count - 1))
+        _LOGGER.warning(
+            f"Reconnecting in {delay} seconds (attempt {self.retry_count})..."
+        )
+        await asyncio.sleep(delay)
+        await self.connect()
+
+    async def run(self):
+        """Run the WebSocket client to handle messages and reconnections."""
+        while self.is_running:
+            if self._client is None:
+                await self.reconnect()
+            if self._client is not None:
+                message = await self.receive()
+                if message and self.callback:
+                    if asyncio.iscoroutinefunction(self.callback):
+                        await self.callback(message)
+                    else:
+                        self.callback(message)
+
+    def status(self) -> dict:
+        """Return the current status of the websocket connection."""
+        _LOGGER.debug("websocket.status() called")
+        return {
+            "host": self.host,
+            "connected": self._client is not None,
+            "closing": self._closing,
+            "retry_interval": self.retry_interval,
+            "max_retries": self.max_retries,
+        }
+
+    @property
+    def connected(self) -> bool:
+        """Return the status of the connection."""
+        return self._client is not None and not self._client.closed
+
+    def __repr__(self) -> str:
+        """Return the representation."""
+        prefix = "" if self.connected else "not "
+        return f"{type(self).__name__}(ws_server_url={self.host}, {prefix}connected)"

python_swidget-1.2.4/swidget/websocket.py

@@ -1,188 +0,0 @@
-"""Module to handle websocket connections to Swidget devices."""
-import asyncio
-import logging
-import socket
-from typing import Any
-
-import aiohttp
-from aiohttp import ClientWebSocketResponse, WSMsgType
-
-_LOGGER = logging.getLogger(__name__)
-
-
-async def cancel_task(*tasks: asyncio.Task | None) -> None:
-    """Cancel task(s)."""
-    for task in tasks:
-        if task is not None and not task.done():
-            task.cancel()
-            try:
-                await task
-            except asyncio.CancelledError:
-                pass
-
-
-class SwidgetWebsocket:
-    """A websocket connection to a Swidget Device."""
-
-    # pylint: disable=too-many-instance-attributes
-    _client: aiohttp.ClientWebSocketResponse | None = None
-
-    def __init__(
-        self,
-        host,
-        token_name,
-        secret_key,
-        callback,
-        session=None,
-        use_security=True,
-    ):
-        self.host = host
-        self.session = session or aiohttp.ClientSession()
-        self.use_security = use_security
-        self.uri = self.get_uri(host, token_name, secret_key)
-        self.callback = callback
-        self._verify_ssl = False
-        self._state = None
-        self.failed_attempts = 0
-        self._error_reason = None
-        self.headers = {"Connection": "Upgrade"}
-        self._receiver_task: asyncio.Task | None = None
-
-    @property
-    def connected(self) -> bool:
-        """Return of status of whether the device is currently connected."""
-        return self._client is not None and not self._client.closed
-
-    @property
-    def websocket(self) -> ClientWebSocketResponse | None:
-        """Return the web socket."""
-        return self._client
-
-    def get_uri(self, host, token_name, secret_key):
-        """Generate the websocket URI."""
-        if self.use_security:
-            return f"wss://{host}/api/v1/sock?{token_name}={secret_key}"
-        else:
-            return f"ws://{host}/api/v1/sock?{token_name}={secret_key}"
-
-    async def connect(self) -> None:
-        """Create a new connection and, optionally, start the monitor."""
-        _LOGGER.debug("websocket.connect() called")
-        await cancel_task(self._receiver_task)
-        if self.connected:
-            _LOGGER.debug("Websocket already connected")
-            return
-
-        if self._client is not None:
-            raise ConnectionError("Already connected")
-
-        if not self.session:
-            raise ConnectionError("No aiohttp session available")
-
-        try:
-            _LOGGER.debug("Trying to connect")
-            self._client = await self.session.ws_connect(
-                url=self.uri,
-                headers=self.headers,
-                verify_ssl=self._verify_ssl,
-                heartbeat=30,
-            )
-            _LOGGER.debug("Websocket now connected")
-        except aiohttp.WSServerHandshakeError as handshake_error:
-            _LOGGER.error(
-                f"Error occurred during websocket handshake: {handshake_error}"
-            )
-            raise
-        except aiohttp.ClientConnectionError as connection_error:
-            _LOGGER.error(
-                f"Error connecting to the websocket server: {connection_error}"
-            )
-            raise
-        except socket.gaierror as gai_error:
-            _LOGGER.error(f"Error resolving host: {gai_error}")
-            raise
-        except Exception as e:
-            _LOGGER.error(f"An unexpected error occurred: {e}")
-            raise
-        self._receiver_task = asyncio.ensure_future(self.listen())
-
-    async def close(self) -> None:
-        """Close the websocket."""
-        _LOGGER.debug("websocket.close() called")
-        if self._client is not None and not self._client.closed:
-            await self._client.close()
-        self._client = None
-
-    async def disconnect(self) -> None:
-        """Wrapper of the close() function."""
-        await self.close()
-
-    async def send_str(self, message):
-        """Send a message through the websocket."""
-        _LOGGER.debug("websocket.send_str() called")
-        if not self.connected:
-            raise ConnectionError
-        message = str(message)
-        _LOGGER.debug(f"Sending messsage over websocket: {message}")
-        await self._client.send_str(f"{message}")
-
-    async def listen(self):
-        """Ask the client to listen to websocket events."""
-        _LOGGER.debug("websocket.listen() called")
-        # Check if the websocket is connected
-        if not self._client or not self.connected:
-            _LOGGER.error("Websocket is not connected")
-            raise ConnectionError("Websocket is not connected")
-
-        while not self._client.closed:
-            try:
-                message = await self._client.receive()
-            except StopAsyncIteration:
-                break
-
-            if message.type == aiohttp.WSMsgType.ERROR:
-                raise ConnectionError("Websocket error occurred")
-
-            if message.type == aiohttp.WSMsgType.TEXT:
-                message_data = message.json()
-                _LOGGER.debug(f"Received from websocket: {message_data}")
-                await self.callback(message_data)
-
-            if message.type in (
-                aiohttp.WSMsgType.CLOSE,
-                aiohttp.WSMsgType.CLOSED,
-                aiohttp.WSMsgType.CLOSING,
-            ):
-                _LOGGER.error("Connection to the Swidget WebSocket has been closed")
-                break
-
-        self._client = None  # Ensure client is set to None when closed
-
-    async def receive_message_or_raise(self) -> Any:
-        """Receive ONE (raw) message or raise."""
-        assert self._client
-        ws_msg = await self._client.receive()
-
-        if ws_msg.type in (WSMsgType.CLOSE, WSMsgType.CLOSED, WSMsgType.CLOSING):
-            raise ConnectionError("Connection was closed.")
-
-        if ws_msg.type == WSMsgType.ERROR:
-            raise ConnectionError
-
-        if ws_msg.type != WSMsgType.TEXT:
-            raise ValueError(f"Received non-Text message: {ws_msg.type}: {ws_msg.data}")
-
-        try:
-            msg = ws_msg.json()
-        except TypeError as err:
-            raise TypeError(f"Received unsupported JSON: {err}") from err
-        except ValueError as err:
-            raise ValueError("Received invalid JSON.") from err
-
-        _LOGGER.debug(f"Received message:\n{msg}\n")
-        return msg
-
-    def __repr__(self) -> str:
-        """Return the representation."""
-        prefix = "" if self.connected else "not "
-        return f"{type(self).__name__}(ws_server_url={self.host}, {prefix}connected)"