python-swidget 1.0.3__tar.gz → 1.2.0__tar.gz

{python_swidget-1.0.3 → python_swidget-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-swidget
-Version: 1.0.3
+Version: 1.2.0
 Summary: Python API for Swidget smart devices
 Home-page: https://github.com/swidget/python-swidget
 License: GPL-3.0-or-later

{python_swidget-1.0.3 → python_swidget-1.2.0}/pyproject.toml

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

{python_swidget-1.0.3 → python_swidget-1.2.0}/swidget/cli.py

@@ -116,8 +116,8 @@ def join(ssid, network_password, secret_key, friendly_name):
     confirmation = click.prompt(f"Are you connected to a wifi network that stars with the name 'Swidget-' (y/n)")
     if confirmation == "y":
         click.echo(f"Asking the device to connect to network {ssid}..")
-        # def provision_wifi(ssid, network_password, token_name, secret_key, friendly_name):
         provision_wifi(friendly_name, ssid, network_password, secret_key)
+        click.echo(f"Disconnect from the `swidget` network and connect back your main WiFi network")
         return True
     else:
         click.echo("Not provisioning wifi")
@@ -164,7 +164,7 @@ async def state(dev: SwidgetDevice):
     click.echo(f"\tMAC (rssi):   {dev.mac_address} ({dev.rssi})")
 
     click.echo(click.style("\n\t== Current State ==", bold=True))
-    realtime_values = await dev.realtime_values
+    realtime_values = dev.realtime_values
     for info_name, info_data in realtime_values.items():
         if isinstance(info_data, list):
             click.echo(f"\t{info_name}:")
@@ -263,11 +263,11 @@ async def enable_debug_server(dev: SwidgetDevice):
 async def check_for_updates(dev: SwidgetDevice):
     click.echo("Contacting Swidget servers to fetch for updates...")
     available_updates = await dev.check_for_updates()
-    if len(available_updates['updates']) == 0:
+    if len(available_updates) == 0:
         click.echo("No available updates")
     else:
         click.echo("The following versions are available to update to")
-        for version in available_updates['updates']:
+        for version in available_updates:
             click.echo(click.style(f"\t+ {version}", fg="green"))
 
 
@@ -278,7 +278,7 @@ async def upgrade(dev: SwidgetDevice, version: str):
     if version is None:
         click.echo("Contacting Swidget servers to fetch for latest version")
         available_updates = await dev.check_for_updates()
-        if len(available_updates['updates']) == 0:
+        if len(available_updates) == 0:
             click.echo("No available updates")
         else:
             version = available_updates[-1]

{python_swidget-1.0.3 → python_swidget-1.2.0}/swidget/swidgetdevice.py

@@ -1,9 +1,10 @@
 import json
 import logging
 import time
+from types import TracebackType
 
 from aiohttp import ClientSession, TCPConnector
-import asyncio
+from collections.abc import Callable
 from enum import Enum
 from typing import Any, Dict, List
 
@@ -23,6 +24,36 @@ class DeviceType(Enum):
     Unknown = -1
 
 
+class InsertType(Enum):
+    """Insert type enum."""
+    USB = "USB"
+    THM = "TEMP HUMI MOTION"
+    TH = "TEMP HUMI"
+    AQ = "AIR QUALITY"
+    GL = "GUIDE LIGHT"
+    PO = "POWER OUT"
+    Unknown = -1
+
+
+class SelfDiagnosticErrorCodes(Enum):
+    """Self-Diagnostic error codes"""
+    UNUSED = 0
+    AQ = 1
+    GUIDELIGHT = 2
+    LIGHT_SENSOR = 3
+    MOTION = 4
+    POWER_OUT = 5
+    PRESSURE = 6
+    TEMP = 7
+    USB = 8
+    VIBRATION = 9
+    VIDEO = 10
+    ADVANCED_GL = 11
+    HUMI = 12
+    CO2 = 13
+    PART_MATTER = 14
+
+
 class SwidgetDevice:
     def __init__(self, host, token_name, secret_key, use_https=True, use_websockets=True) -> None:
         self.token_name = token_name
@@ -34,6 +65,7 @@ class SwidgetDevice:
         self.device_type = DeviceType.Unknown
         self._friendly_name = "Unknown Swidget Device"
         self.assemblies: Dict[Any, Any] = dict()
+        self._subscribers: Callable[[Dict[str, Any]], Any] = list()
         headers = {self.token_name: self.secret_key,
                    'Connection': 'keep-alive'}
         connector = TCPConnector(verify_ssl=False, force_close=True)
@@ -47,6 +79,10 @@ class SwidgetDevice:
                 callback=self.message_callback,
                 session=self._session)
 
+    @property
+    def connected(self) -> bool:
+        return self._websocket.connected
+
     def get_websocket(self) -> SwidgetWebsocket | None:
         if self.use_websockets:
             return self._websocket
@@ -77,6 +113,20 @@ class SwidgetDevice:
     async def close(self) -> None:
         await self.stop()
 
+    async def add_event_callback(self, callback: Callable[[Dict, Any], None],) -> bool:
+        for c in self._subscribers:
+            if c == callback:
+                _LOGGER.warn(f"Callback has already been added, not adding the same callback function again")
+                return False
+        self._subscribers.append(callback)
+        return True
+
+    async def remove_event_callback(self, callback: Callable[[Dict, Any], None],) -> bool:
+        if callback in self._subscribers:
+            self._subscribers.remove(callback)
+            return True
+        return False
+
     async def message_callback(self, message) -> None:
         """Entrypoint for a websocket callback"""
         _LOGGER.debug("SwidgetDevice.message_callback() called")
@@ -88,6 +138,12 @@ class SwidgetDevice:
             await self.process_state(message)
         else:
             _LOGGER.error(f"Unknown message type from websocket. Type given was: {message["request_id"]}")
+        await self.signal_callbacks(message)
+
+    async def signal_callbacks(self, message):
+        _LOGGER.debug("SwidgetDevice.signal_callsbacks() called")
+        for callback in self._subscribers:
+            await callback(message)
 
     async def get_summary(self) -> None:
         """Get a summary of the device over HTTP"""
@@ -213,7 +269,7 @@ class SwidgetDevice:
             function_value = state[assembly]["components"][component][function]
             self.assemblies[assembly].components[component].functions[function] = function_value  # fmt: skip
 
-    async def ping(self) -> int | SwidgetException:
+    async def ping(self) -> bool:
         """Ping the device to ensure it's devices
 
         :raises SwidgetException: Raise the exception if there we are unable to connect to the Swidget device
@@ -224,9 +280,11 @@ class SwidgetDevice:
                 url=f"{self.uri_scheme}://{self.ip_address}/ping",
                 ssl=False
             ) as response:
-                return response.status
+                if response.status == 200:
+                    return True
+                return False
         except:
-            raise SwidgetException
+            return False
 
     async def blink(self) -> Any:
         """Make the device LED blink
@@ -254,7 +312,9 @@ class SwidgetDevice:
                 url=f"{self.uri_scheme}://{self.ip_address}/debug?x-secret-key={self.secret_key}",
                 ssl=False
             ) as response:
-                return await response.json()
+                if response.status == 200:
+                    return True
+                return False
         except:
             raise SwidgetException
 
@@ -284,7 +344,8 @@ class SwidgetDevice:
                 url=f"{self.uri_scheme}://{self.ip_address}/api/v1/update",
                 ssl=False
             ) as response:
-                return await response.json()
+                newer_versions = await response.json()
+                return sorted(newer_versions['updates'])
         except:
             raise SwidgetException
 
@@ -298,11 +359,14 @@ class SwidgetDevice:
                 "version": version
             }
             async with self._session.post(
-                url=f"{self.uri_scheme}://{self.ip_address}/api/v1/update",
+                url=f"{self.uri_scheme}://{self.ip_address}/api/v1/update/version",
                 ssl=False,
                 data=json.dumps(data)
             ) as response:
-                return await response.json()
+                result = await response.status
+                if result == 200:
+                    return True
+                return False
         except:
             raise SwidgetException
 
@@ -428,6 +492,7 @@ class SwidgetDevice:
     @property  # type: ignore
     def is_on(self) -> bool:
         """Return whether device is on."""
+        _LOGGER.debug("SwidgetDevice.is_on called")
         dimmer_state = self.assemblies['host'].components["0"].functions['toggle']["state"]
         if dimmer_state == "on":
             return True
@@ -436,6 +501,7 @@ class SwidgetDevice:
     async def turn_on(self) -> None:
         """Turn the device on."""
         _LOGGER.debug("SwidgetDevice.turn_on() called")
+        self.assemblies['host'].components["0"].functions['toggle']["state"] = "on"
         await self.send_command(
             assembly="host", component="0", function="toggle", command={"state": "on"}
         )
@@ -443,18 +509,23 @@ class SwidgetDevice:
     async def turn_off(self) -> None:
         """Turn the device off."""
         _LOGGER.debug("SwidgetDevice.turn_off() called")
+        self.assemblies['host'].components["0"].functions['toggle']["state"] = "off"
         await self.send_command(
             assembly="host", component="0", function="toggle", command={"state": "off"}
         )
 
     async def turn_on_usb_insert(self) -> None:
         """Turn the USB insert on."""
+        _LOGGER.debug("SwidgetDevice.turn_on_usb_insert() called")
+        self.assemblies['insert'].components["usb"].functions['toggle']["state"] = "on"
         await self.send_command(
             assembly="insert", component="usb", function="toggle", command={"state": "on"}
         )
 
     async def turn_off_usb_insert(self) -> None:
         """Turn the USB insert off."""
+        _LOGGER.debug("SwidgetDevice.turn_off_usb_insert() called")
+        self.assemblies['insert'].components["usb"].functions['toggle']["state"] = "off"
         await self.send_command(
             assembly="insert", component="usb", function="toggle", command={"state": "off"}
         )
@@ -462,11 +533,29 @@ class SwidgetDevice:
     @property  # type: ignore
     def usb_is_on(self) -> bool:
         """Return whether USB is on."""
+        _LOGGER.debug("SwidgetDevice.usb_is_on called")
         usb_state = self.assemblies['insert'].components["usb"].functions['toggle']["state"]
         if usb_state == "on":
             return True
         return False
 
+    async def __aenter__(self) -> "SwidgetDevice":
+        """Initialize and connect the Swidget Websocket client."""
+        await self.connect()
+        return self
+
+    async def __aexit__(
+        self, exc_type: Exception, exc_value: str, traceback: TracebackType
+    ) -> None:
+        """Disconnect from the websocket."""
+        await self.disconnect()
+
+    def __repr__(self) -> str:
+        """Return the representation."""
+        url = self.connection.ws_server_url
+        prefix = "" if self.connection.connected else "not "
+        return f"{type(self).__name__}(ws_server_url={url!r}, {prefix}connected)"
+
     def __repr__(self) -> str:
         if self._last_update == 0:
             return f"<{self.device_type} at {self.ip_address} - update() needed>"

{python_swidget-1.0.3 → python_swidget-1.2.0}/swidget/swidgetdimmer.py

@@ -13,7 +13,7 @@ class SwidgetDimmer(SwidgetDevice):
 
     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 = "dimmer"
+        self._device_type = DeviceType.Dimmer
 
     @property  # type: ignore
     def brightness(self) -> int:
@@ -21,6 +21,7 @@ class SwidgetDimmer(SwidgetDevice):
 
         Will return a range between 0 - 100.
         """
+        _LOGGER.debug("SwidgetDimmer.brightness called")
         if not self.is_dimmable:
             raise SwidgetException("Device is not dimmable.")
         try:
@@ -30,13 +31,14 @@ class SwidgetDimmer(SwidgetDevice):
 
     async def set_brightness(self, brightness) -> None:
         """Set the brightness of the device."""
-        _LOGGER.debug("SwidgetDimmer.set_brightness() called")
+        _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}
         )
 
     async def set_default_brightness(self, brightness) -> None:
-        _LOGGER.debug("SwidgetDimmer.set_default_brightness() called")
+        _LOGGER.debug("SwidgetDimmer.set_default_brightness() called with brightness: {brightness}")
         await self.send_command(
             assembly="host", component="0", function="level", command={"default": brightness}
         )
@@ -44,4 +46,5 @@ class SwidgetDimmer(SwidgetDevice):
     @property  # type: ignore
     def is_dimmable(self) -> bool:
         """Whether the switch supports brightness changes."""
+        _LOGGER.debug("SwidgetDimmer.is_dimmable() called")
         return True

{python_swidget-1.0.3 → python_swidget-1.2.0}/swidget/websocket.py

@@ -3,6 +3,7 @@ import aiohttp
 from aiohttp import ClientWebSocketResponse, WSMsgType
 import logging
 import socket
+from typing import Any
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -69,10 +70,14 @@ class SwidgetWebsocket:
             _LOGGER.debug("Websocket already connected")
             return
 
+        if self._client is not None:
+            raise ConnectionError("Already connected")
+
         if not self.session:
-            raise
+            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:
@@ -91,13 +96,18 @@ class SwidgetWebsocket:
 
     async def close(self) -> None:
         _LOGGER.debug("websocket.close() called")
-        if not self._client or not self.connected:
-            return
-        await self._client.close()
+        if self._client is not None and not self._client.closed:
+            await self._client.close()
+        self._client = None
+
+    async def disconnect(self) -> None:
+        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}')
@@ -115,6 +125,7 @@ class SwidgetWebsocket:
 
             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 (
@@ -122,4 +133,35 @@ class SwidgetWebsocket:
                 aiohttp.WSMsgType.CLOSED,
                 aiohttp.WSMsgType.CLOSING,
             ):
-                _LOGGER.debug("Connection to the Swidget WebSocket on has been closed")
+                _LOGGER.error("Connection to the Swidget WebSocket on has been closed")
+
+    async def receive_message_or_raise(self) -> Any:
+        """Receive ONE (raw) message or raise."""
+        assert self._ws_client
+        ws_msg = await self._ws_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)"