python-swidget 1.2.2__py3-none-any.whl → 1.2.4__py3-none-any.whl

swidget/swidgetdimmer.py

@@ -1,18 +1,30 @@
+"""Module for SwidgetDimmer."""
 import logging
 
-from swidget.swidgetdevice import (
-    DeviceType,
-    SwidgetDevice
-)
 from swidget.exceptions import SwidgetException
+from swidget.swidgetdevice import DeviceType, SwidgetDevice
 
 _LOGGER = logging.getLogger(__name__)
 
 
 class SwidgetDimmer(SwidgetDevice):
+    """Representation of a Swidget Dimmer device."""
 
-    def __init__(self, host,  token_name: str, secret_key: str, use_https: bool, use_websockets: bool) -> None:
-        super().__init__(host=host, token_name=token_name, secret_key=secret_key, use_https=use_https, use_websockets=use_websockets)
+    def __init__(
+        self,
+        host,
+        token_name: str,
+        secret_key: str,
+        use_https: bool,
+        use_websockets: bool,
+    ) -> None:
+        super().__init__(
+            host=host,
+            token_name=token_name,
+            secret_key=secret_key,
+            use_https=use_https,
+            use_websockets=use_websockets,
+        )
         self._device_type = DeviceType.Dimmer
 
     @property  # type: ignore
@@ -25,26 +37,37 @@ class SwidgetDimmer(SwidgetDevice):
         if not self.is_dimmable:
             raise SwidgetException("Device is not dimmable.")
         try:
-            return self.assemblies['host'].components["0"].functions["level"]["now"]
+            return self.assemblies["host"].components["0"].functions["level"]["now"]
         except KeyError:
-            return self.assemblies['host'].components["0"].functions["level"]["default"]
+            return self.assemblies["host"].components["0"].functions["level"]["default"]
 
     async def set_brightness(self, brightness) -> None:
         """Set the brightness of the device."""
-        _LOGGER.debug("SwidgetDimmer.set_brightness() called with brightness: {brightness}")
-        self.assemblies['host'].components["0"].functions["level"]["now"] = brightness
+        _LOGGER.debug(
+            "SwidgetDimmer.set_brightness() called with brightness: {brightness}"
+        )
+        self.assemblies["host"].components["0"].functions["level"]["now"] = brightness
         await self.send_command(
-            assembly="host", component="0", function="level", command={"now": brightness}
+            assembly="host",
+            component="0",
+            function="level",
+            command={"now": brightness},
         )
 
     async def set_default_brightness(self, brightness) -> None:
-        _LOGGER.debug("SwidgetDimmer.set_default_brightness() called with brightness: {brightness}")
+        """Set the brightness of the device when it is turned on."""
+        _LOGGER.debug(
+            "SwidgetDimmer.set_default_brightness() called with brightness: {brightness}"
+        )
         await self.send_command(
-            assembly="host", component="0", function="level", command={"default": brightness}
+            assembly="host",
+            component="0",
+            function="level",
+            command={"default": brightness},
         )
 
     @property  # type: ignore
     def is_dimmable(self) -> bool:
         """Whether the switch supports brightness changes."""
         _LOGGER.debug("SwidgetDimmer.is_dimmable() called")
-        return True
+        return True

swidget/swidgetoutlet.py

@@ -1,11 +1,23 @@
-from swidget.swidgetdevice import (
-    DeviceType,
-    SwidgetDevice
-)
+"""Module for SwidgetOutlet."""
+from swidget.swidgetdevice import DeviceType, SwidgetDevice
 
 
 class SwidgetOutlet(SwidgetDevice):
+    """Representation of a Swidget Outlet device."""
 
-    def __init__(self, host,  token_name: str, secret_key: str, use_https: bool, use_websockets: bool) -> None:
-        super().__init__(host=host, token_name=token_name, secret_key=secret_key, use_https=use_https, use_websockets=use_websockets)
-        self._device_type = DeviceType.Outlet
+    def __init__(
+        self,
+        host,
+        token_name: str,
+        secret_key: str,
+        use_https: bool,
+        use_websockets: bool,
+    ) -> None:
+        super().__init__(
+            host=host,
+            token_name=token_name,
+            secret_key=secret_key,
+            use_https=use_https,
+            use_websockets=use_websockets,
+        )
+        self._device_type = DeviceType.Outlet

swidget/swidgetswitch.py

@@ -1,11 +1,23 @@
-from swidget.swidgetdevice import (
-    DeviceType,
-    SwidgetDevice
-)
+"""Module for a generic SwidgetSwitch."""
+from swidget.swidgetdevice import DeviceType, SwidgetDevice
 
 
 class SwidgetSwitch(SwidgetDevice):
+    """Representation of a Swidget Switch device."""
 
-    def __init__(self, host,  token_name: str, secret_key: str, use_https: bool, use_websockets: bool) -> None:
-        super().__init__(host=host, token_name=token_name, secret_key=secret_key, use_https=use_https, use_websockets=use_websockets)
-        self._device_type = DeviceType.Switch
+    def __init__(
+        self,
+        host,
+        token_name: str,
+        secret_key: str,
+        use_https: bool,
+        use_websockets: bool,
+    ) -> None:
+        super().__init__(
+            host=host,
+            token_name=token_name,
+            secret_key=secret_key,
+            use_https=use_https,
+            use_websockets=use_websockets,
+        )
+        self._device_type = DeviceType.Switch

swidget/swidgettimerswitch.py

@@ -1,23 +1,39 @@
+"""Module for SwidgetTimerSwitch."""
 import logging
 from typing import Any
 
-from swidget.swidgetdevice import (
-    DeviceType,
-)
+from swidget.swidgetdevice import DeviceType
 from swidget.swidgetswitch import SwidgetSwitch
 
 _LOGGER = logging.getLogger(__name__)
 
 
 class SwidgetTimerSwitch(SwidgetSwitch):
+    """Class to represent a Swidget Timer Switch (also known as a 20/40/60 switch)."""
 
-    def __init__(self, host,  token_name: str, secret_key: str, use_https: bool, use_websockets: bool) -> None:
-        super().__init__(host=host, token_name=token_name, secret_key=secret_key, use_https=use_https, use_websockets=use_websockets)
+    def __init__(
+        self,
+        host,
+        token_name: str,
+        secret_key: str,
+        use_https: bool,
+        use_websockets: bool,
+    ) -> None:
+        super().__init__(
+            host=host,
+            token_name=token_name,
+            secret_key=secret_key,
+            use_https=use_https,
+            use_websockets=use_websockets,
+        )
         self._device_type = DeviceType.TimerSwitch
 
     async def set_countdown_timer(self, minutes) -> Any:
         """Set the countdown timer."""
         _LOGGER.debug("SwidgetTimerSwitch.set_brightness() called")
         await self.send_command(
-            assembly="host", component="0", function="timer", command={"duration": minutes}
-        )
+            assembly="host",
+            component="0",
+            function="timer",
+            command={"duration": minutes},
+        )

swidget/websocket.py

@@ -1,10 +1,12 @@
+"""Module to handle websocket connections to Swidget devices."""
 import asyncio
-import aiohttp
-from aiohttp import ClientWebSocketResponse, WSMsgType
 import logging
 import socket
 from typing import Any
 
+import aiohttp
+from aiohttp import ClientWebSocketResponse, WSMsgType
+
 _LOGGER = logging.getLogger(__name__)
 
 
@@ -20,7 +22,7 @@ async def cancel_task(*tasks: asyncio.Task | None) -> None:
 
 
 class SwidgetWebsocket:
-    """A websocket connection to a Swidget Device"""
+    """A websocket connection to a Swidget Device."""
 
     # pylint: disable=too-many-instance-attributes
     _client: aiohttp.ClientWebSocketResponse | None = None
@@ -43,11 +45,12 @@ class SwidgetWebsocket:
         self._state = None
         self.failed_attempts = 0
         self._error_reason = None
-        self.headers = {'Connection': 'Upgrade'}
+        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
@@ -56,15 +59,15 @@ class SwidgetWebsocket:
         return self._client
 
     def get_uri(self, host, token_name, secret_key):
-        """Generate the websocket URI"""
+        """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:
-        _LOGGER.debug("websocket.connect() called")
         """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")
@@ -78,13 +81,22 @@ class SwidgetWebsocket:
 
         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)
+            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}")
+            _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}")
+            _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}")
@@ -95,12 +107,14 @@ class SwidgetWebsocket:
         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):
@@ -110,18 +124,24 @@ class SwidgetWebsocket:
             raise ConnectionError
         message = str(message)
         _LOGGER.debug(f"Sending messsage over websocket: {message}")
-        await self._client.send_str(f'{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:
-            raise
+            _LOGGER.error("Websocket is not connected")
+            raise ConnectionError("Websocket is not connected")
 
         while not self._client.closed:
-            message = await self._client.receive()
+            try:
+                message = await self._client.receive()
+            except StopAsyncIteration:
+                break
 
             if message.type == aiohttp.WSMsgType.ERROR:
-                raise
+                raise ConnectionError("Websocket error occurred")
 
             if message.type == aiohttp.WSMsgType.TEXT:
                 message_data = message.json()
@@ -133,7 +153,10 @@ class SwidgetWebsocket:
                 aiohttp.WSMsgType.CLOSED,
                 aiohttp.WSMsgType.CLOSING,
             ):
-                _LOGGER.error("Connection to the Swidget WebSocket on has been closed")
+                _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."""
@@ -147,9 +170,7 @@ class SwidgetWebsocket:
             raise ConnectionError
 
         if ws_msg.type != WSMsgType.TEXT:
-            raise ValueError(
-                f"Received non-Text message: {ws_msg.type}: {ws_msg.data}"
-            )
+            raise ValueError(f"Received non-Text message: {ws_msg.type}: {ws_msg.data}")
 
         try:
             msg = ws_msg.json()
@@ -164,4 +185,4 @@ class SwidgetWebsocket:
     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)"
+        return f"{type(self).__name__}(ws_server_url={self.host}, {prefix}connected)"

python_swidget-1.2.2.dist-info/RECORD

@@ -1,16 +0,0 @@
-swidget/__init__.py,sha256=sUaN7mSvEe40HDHjtEiqUtUGdb3239XbFLb14PnOpHw,1330
-swidget/cli.py,sha256=G61GQijygVL1W59EQVVk3dA7SOikWhZsZ5iy33cB5FQ,8951
-swidget/discovery.py,sha256=b5-C75d0qNl3-PGK6vq5i02uTFaRlQq_yc6l_qG4FmM,3865
-swidget/exceptions.py,sha256=JOSwaOwwv8YLry687vZmTQLY-BrrTpCs0CIZr7u-J48,79
-swidget/provision.py,sha256=Mw_0lHUj584F6fg2H80WVOd3Iz57C300hDnNDi1TSIw,4591
-swidget/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-swidget/swidgetdevice.py,sha256=HdRyiQ3S0X8Dxq3p07Ksbbk5Xer39pVWPtPSPnf9ex8,21853
-swidget/swidgetdimmer.py,sha256=doPajuRoSSI0aU3WlT-t_WZyxsRyxAB-uMiXYz-YP88,1969
-swidget/swidgetoutlet.py,sha256=XUz42SV3_CaNp0gOGtBa1rAqG5xpmGpdLMem-OHCMM4,402
-swidget/swidgetswitch.py,sha256=VorjxnV42wWmu77CmWaasrMOAFIO15tQReRyaN7D-qU,402
-swidget/swidgettimerswitch.py,sha256=7-F81U7VWi-YCW6vYyOcZyKjttHCuW_P5LLbtLmdzfk,820
-swidget/websocket.py,sha256=27wCxJNmOAK1ba8lLQ3kxXEgg6Cp30Uri6P5OpaWV00,5768
-python_swidget-1.2.2.dist-info/METADATA,sha256=vbkdFQ4SWOjMgYuZi3Gne1uiiezeuNg55hjc-Q1379Q,1853
-python_swidget-1.2.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-python_swidget-1.2.2.dist-info/entry_points.txt,sha256=ksGZuoFNqyktLnxPUCFDHokC_7n1uu4GSMUEerwwDmY,43
-python_swidget-1.2.2.dist-info/RECORD,,