python-swidget 0.0.32__tar.gz → 1.0.1__tar.gz

{python_swidget-0.0.32 → python_swidget-1.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-swidget
-Version: 0.0.32
+Version: 1.0.1
 Summary: Python API for Swidget smart devices
 Home-page: https://github.com/swidget/python-swidget
 License: GPL-3.0-or-later
@@ -31,3 +31,21 @@ Description-Content-Type: text/markdown
 # python-swidget
 A library to manage Swidget smart devices
 
+# Basic Usage
+
+## Connect to the device using http/ https
+```
+    dev = SwidgetDimmer(host=host, token_name='x-secret-key', secret_key='password', use_https=True, use_websockets=False)
+    dev.update()
+    dev.turn_on()
+    dev.close()
+```
+
+## Connect to the device using websockets
+```
+    dev = SwidgetDimmer(host=host, token_name='x-secret-key', secret_key='password', use_https=True, use_websockets=True)
+    dev.start()
+    dev.update()
+    dev.turn_on()
+    dev.close()
+```

python_swidget-1.0.1/README.md

@@ -0,0 +1,21 @@
+# python-swidget
+A library to manage Swidget smart devices
+
+# Basic Usage
+
+## Connect to the device using http/ https
+```
+    dev = SwidgetDimmer(host=host, token_name='x-secret-key', secret_key='password', use_https=True, use_websockets=False)
+    dev.update()
+    dev.turn_on()
+    dev.close()
+```
+
+## Connect to the device using websockets
+```
+    dev = SwidgetDimmer(host=host, token_name='x-secret-key', secret_key='password', use_https=True, use_websockets=True)
+    dev.start()
+    dev.update()
+    dev.turn_on()
+    dev.close()
+```

{python_swidget-0.0.32 → python_swidget-1.0.1}/pyproject.toml

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

{python_swidget-0.0.32 → python_swidget-1.0.1}/swidget/cli.py

@@ -1,5 +1,4 @@
 """python-swidget cli tool."""
-import asyncio
 import logging
 import sys
 from pprint import pformat as pf
@@ -47,6 +46,10 @@ pass_dev = click.make_pass_decorator(SwidgetDevice)
     envvar="SWIDGET_DEBUG",
     default=False,
     is_flag=True)
+@click.option("--http_only",
+    envvar="SWIDGET_HTTP_ONLY",
+    default=True,
+    is_flag=True)
 @click.option(
     "--type",
     envvar="SWIDGET_TYPE",
@@ -55,7 +58,7 @@ pass_dev = click.make_pass_decorator(SwidgetDevice)
 )
 @click.version_option(package_name="python-swidget")
 @click.pass_context
-async def cli(ctx, host, password, debug, type):
+async def cli(ctx, host, password, debug, http_only, type):
     """A tool for controlling Swidget smart home devices."""  # noqa
     # no need to perform any checks if we are just displaying the help
     if sys.argv[-1] == "--help":
@@ -68,7 +71,6 @@ async def cli(ctx, host, password, debug, type):
 
     if ctx.invoked_subcommand == "discover" or ctx.invoked_subcommand == "wifi":
         return
-
     if host is None:
         click.echo("No host name given, trying discovery..")
         await ctx.invoke(discover)
@@ -77,15 +79,16 @@ async def cli(ctx, host, password, debug, type):
         dev = TYPE_TO_CLASS[type](host=host,
                                   token_name='x-secret-key',
                                   secret_key=password,
-                                  ssl=False,
+                                  use_https=http_only,
                                   use_websockets=False)
     else:
         click.echo("No --type defined, discovering...")
         dev = await discover_single(host=host,
                                     token_name='x-secret-key',
                                     password=password,
-                                    ssl=False,
+                                    use_https=http_only,
                                     use_websockets=False)
+        await dev.update()
 
     @asynccontextmanager
     async def async_wrapped_device(dev: SwidgetDevice):
@@ -104,7 +107,7 @@ async def cli(ctx, host, password, debug, type):
 def wifi():
     """Commands to control wifi settings."""
 
-#@ click.argument("ssid")
+
 @wifi.command()
 @click.option("--ssid", prompt=True, hide_input=False)
 @click.option("--network_password", prompt=True, hide_input=True)
@@ -124,7 +127,7 @@ def join(ssid, network_password, secret_key, friendly_name):
 
 
 @cli.command()
-@click.option("--timeout", default=5, required=False)
+@click.option("--timeout", default=10, required=False)
 @click.pass_context
 async def discover(ctx, timeout):
     """Discover devices in the network."""
@@ -225,6 +228,20 @@ async def blink(dev):
     return await dev.blink()
 
 
+@cli.command()
+@pass_dev
+async def ping(dev):
+    """Ping the device"""
+    click.echo(f"Pinging the device")
+    try:
+        result = await dev.ping()
+        if result == 200:
+            click.echo("Successfully pinged device")
+        else:
+            click.echo(result.status_code)
+    except:
+        click.echo("Unable to ping device")
+
 @cli.command()
 @pass_dev
 async def on(dev: SwidgetDevice):
@@ -240,6 +257,7 @@ async def off(dev: SwidgetDevice):
     click.echo(f"Turning off {dev.friendly_name}")
     return await dev.turn_off()
 
+
 @cli.command()
 @pass_dev
 async def enable_debug_server(dev: SwidgetDevice):
@@ -248,5 +266,34 @@ async def enable_debug_server(dev: SwidgetDevice):
     return await dev.enable_debug_server()
 
 
+@cli.command()
+@pass_dev
+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:
+        click.echo("No available updates")
+    else:
+        click.echo("The following versions are available to update to")
+        for version in available_updates['updates']:
+            click.echo(click.style(f"\t+ {version}", fg="green"))
+
+
+@cli.command()
+@click.option("--version", required=False)
+@pass_dev
+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:
+            click.echo("No available updates")
+        else:
+            version = available_updates[-1]
+    click.echo(f"Upgrading to version: {version}")
+    response = await dev.update_version(version)
+    click.echo(response)
+
+
 if __name__ == "__main__":
     cli()

{python_swidget-0.0.32 → python_swidget-1.0.1}/swidget/discovery.py

@@ -65,21 +65,26 @@ async def discover_devices(timeout=RESPONSE_SEC):
     return devices
 
 
-async def discover_single(host: str, token_name: str, password: str, ssl: bool, use_websockets: bool) -> SwidgetDevice:
+async def discover_single(host: str, token_name: str, password: str, use_https: bool, use_websockets: bool) -> SwidgetDevice:
     """Discover a single device by the given IP address.
 
     :param host: Hostname of device to query
     :rtype: SwidgetDevice
     :return: Object for querying/controlling found device.
     """
-    swidget_device = SwidgetDevice(host, token_name, password, ssl, use_websockets)
+    _LOGGER.debug(f"Checking for device at {host}")
+    swidget_device = SwidgetDevice(host, token_name, password, use_https, use_websockets=False)
+    _LOGGER.debug(f"Asking {host} for summary data")
     await swidget_device.get_summary()
     device_type = swidget_device.device_type
+    _LOGGER.debug(f"{host} is of type {device_type}")
     await swidget_device.stop()
 
+    _LOGGER.debug(f"Creating new device class of type: {device_type}")
     device_class = _get_device_class(device_type)
-    dev = device_class(host, token_name, password, ssl, use_websockets)
-    await dev.update()
+    _LOGGER.debug(f"{device_class}")
+    dev = device_class(host, token_name, password, use_https, use_websockets)
+    await dev.start()
     return dev
 
 

{python_swidget-0.0.32 → python_swidget-1.0.1}/swidget/provision.py

@@ -43,6 +43,7 @@ def send_credentials(device_name, ssid, network_password, secret_key):
             time.sleep(5)
             sentProvisionRequestAttempts += 1
 
+
 def verify_connect_result(key):
     headers = {'x-secret-key': key}
     connect_success = False

{python_swidget-0.0.32 → python_swidget-1.0.1}/swidget/swidgetdevice.py

@@ -3,6 +3,7 @@ import logging
 import time
 
 from aiohttp import ClientSession, TCPConnector
+import asyncio
 from enum import Enum
 from typing import Dict, List, Set
 
@@ -11,7 +12,6 @@ from .websocket import SwidgetWebsocket
 
 _LOGGER = logging.getLogger(__name__)
 
-
 class DeviceType(Enum):
     """Device type enum."""
 
@@ -24,16 +24,20 @@ class DeviceType(Enum):
 
 
 class SwidgetDevice:
-    def __init__(self, host, token_name, secret_key, ssl=False, use_websockets=True):
+    def __init__(self, host, token_name, secret_key, use_https=True, use_websockets=True):
         self.token_name = token_name
         self.ip_address = host
-        self.ssl = ssl
+
+        self.use_https = use_https
+        self.uri_scheme = 'https' if self.use_https is True else 'http'
         self.secret_key = secret_key
         self.use_websockets = use_websockets
         self.device_type = DeviceType.Unknown
         self._friendly_name = "Unknown Swidget Device"
-        headers = {self.token_name: self.secret_key}
-        connector = TCPConnector(verify_ssl=ssl, force_close=True)
+        self.assemblies = {}
+        headers = {self.token_name: self.secret_key,
+                   'Connection': 'keep-alive'}
+        connector = TCPConnector(verify_ssl=False, force_close=True)
         self._session = ClientSession(headers=headers, connector=connector)
         self._last_update = None
         if self.use_websockets:
@@ -45,37 +49,65 @@ class SwidgetDevice:
                 session=self._session)
 
     def get_websocket(self):
-        return self._websocket
+        if self.use_websockets:
+            return self._websocket
+        return None
 
     def set_countdown_timer(self, minutes):
         raise NotImplementedError()
 
+    async def connect(self):
+        await self._websocket.connect()
+
+    async def start(self):
+        """Start the websocket."""
+        _LOGGER.debug("SwidgetDevice.start()")
+        if self.use_websockets:
+            _LOGGER.debug("Calling self._websocket.connect()")
+            await self._websocket.connect()
+        _LOGGER.debug("Calling self.update() ")
+        await self.update()
+
     async def stop(self):
         """Stop the websocket."""
+        _LOGGER.debug("SwidgetDevice.stop()")
         if hasattr(self, '_websocket'):
             await self._websocket.close()
         await self._session.close()
 
+    async def close(self):
+        await self.stop()
+
     async def message_callback(self, message):
         """Entrypoint for a websocket callback"""
+        _LOGGER.debug("SwidgetDevice.message_callback() called")
         if message["request_id"] == "summary":
+            _LOGGER.debug("Calling SwidgetDevice.process_summary()")
             await self.process_summary(message)
         elif message["request_id"] == "state" or message["request_id"] == "DYNAMIC_UPDATE" or message["request_id"] == "command":
+            _LOGGER.debug("Calling SwidgetDevice.process_state()")
             await self.process_state(message)
+        else:
+            _LOGGER.error(f"Unknown message type from websocket. Type given was: {message["request_id"]}")
 
     async def get_summary(self):
         """Get a summary of the device over HTTP"""
-        try:
+        _LOGGER.debug("SwidgetDevice.get_summary() called")
+        if self.use_websockets:
+            _LOGGER.debug("In websocket mode. Sending get_summary() command over websocket")
+            await self._websocket.send_str(json.dumps({"type": "summary", "request_id": "summary"}))
+        else:
+            _LOGGER.debug("In http mode. Sending get_summary() command over http")
             async with self._session.get(
-                url=f"https://{self.ip_address}/api/v1/summary", ssl=self.ssl
+                url=f"{self.uri_scheme}://{self.ip_address}/api/v1/summary", ssl=False
             ) as response:
                 summary = await response.json()
             await self.process_summary(summary)
-        except:
-            raise SwidgetException("Unable to connect to device")
 
     async def process_summary(self, summary):
         """ Process the data around the summary of the device"""
+        _LOGGER.debug("SwidgetDevice.process_summary() called")
+        _LOGGER.debug(f"Summary to process: {summary}")
         self.model = summary["model"]
         self.mac_address = summary["mac"]
         self.version = summary["version"]
@@ -89,9 +121,10 @@ class SwidgetDevice:
         self._last_update = int(time.time())
 
     async def get_friendly_name(self):
+        _LOGGER.debug("SwidgetDevice.get_friendly_name() called")
         try:
             async with self._session.get(
-                url=f"https://{self.ip_address}/api/v1/name", ssl=self.ssl
+                url=f"{self.uri_scheme}://{self.ip_address}/api/v1/name", ssl=False
             ) as response:
                 name = await response.json()
         except Exception:
@@ -99,24 +132,33 @@ class SwidgetDevice:
         await self.process_friendly_name(name['name'])
 
     async def process_friendly_name(self, name):
+        _LOGGER.debug("SwidgetDevice.process_friendly_name() called")
         self._friendly_name = name
+        self._last_update = int(time.time())
 
     async def get_state(self):
         """ Get the state of the device over HTTP"""
-        async with self._session.get(
-            url=f"https://{self.ip_address}/api/v1/state", ssl=self.ssl
-        ) as response:
-            state = await response.json()
-        await self.process_state(state)
+        _LOGGER.debug("SwidgetDevice.get_state() called")
+        if self.use_websockets:
+            _LOGGER.debug("In websocket mode. Sending get_summary() command over websocket")
+            await self._websocket.send_str(json.dumps({"type": "state", "request_id": "state"}))
+        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/state", ssl=False
+            ) as response:
+                state = await response.json()
+            await self.process_state(state)
 
     async def process_state(self, state):
         """ Process any information about the state of the device or insert"""
         # State is not always in the state (during callback)
+        _LOGGER.debug("SwidgetDevice.process_state() called")
+        _LOGGER.debug(f"State to process: {state}")
         try:
             self.rssi = state["connection"]["rssi"]
         except:
             pass
-
         for assembly in self.assemblies:
             for id, component in self.assemblies[assembly].components.items():
                 try:
@@ -126,37 +168,49 @@ class SwidgetDevice:
         self._last_update = int(time.time())
 
     async def update(self):
+        _LOGGER.debug("SwidgetDevice.update() called")
         if self._last_update is None:
             _LOGGER.debug("Performing the initial update to obtain sysinfo")
-        await self.get_summary()
-        await self.get_state()
-        if self._friendly_name == "Unknown Swidget Device":
-            await self.get_friendly_name()
+            await self.get_summary()
+            await self.get_state()
+            if self._friendly_name == "Unknown Swidget Device":
+                await self.get_friendly_name()
+        elif (int(time.time()) - self._last_update) < 5:
+            _LOGGER.debug("update() recently called, not executing")
+        else:
+            _LOGGER.debug("Requesting an update of the device")
+            await self.get_summary()
+            await self.get_state()
 
     async def send_config(self, payload: dict):
-        data = json.dumps({"type":"config","request_id":"abcd", "payload": payload})
+        _LOGGER.debug("SwidgetDevice.send_config() called")
+        data = json.dumps({"type":"config","request_id":"send_config", "payload": payload})
         await self._websocket.send_str(data)
 
     async def send_command(
         self, assembly: str, component: str, function: str, command: dict
     ):
+        _LOGGER.debug("SwidgetDevice.send_command() called")
         """Send a command to the Swidget device either using a HTTP call or the existing websocket"""
         data = {assembly: {"components": {component: {function: command}}}}
-
+        _LOGGER.debug(f"Command to send: {data}")
         if self.use_websockets:
+            _LOGGER.debug("In websocket mode. Sending command over websocket")
             data = json.dumps({"type": "command",
                                "request_id": "command",
                                "payload": data
                                })
             await self._websocket.send_str(data)
         else:
+            _LOGGER.debug("NOT in websocket mode, sending command over HTTP")
             async with self._session.post(
-                url=f"https://{self.ip_address}/api/v1/command",
-                ssl=self.ssl,
+                url=f"{self.uri_scheme}://{self.ip_address}/api/v1/command",
+                ssl=False,
                 data=json.dumps(data),
             ) as response:
                 state = await response.json()
 
+            # Do a hard set of the new state of the device. May change this in the future
             function_value = state[assembly]["components"][component][function]
             self.assemblies[assembly].components[component].functions[function] = function_value  # fmt: skip
 
@@ -165,12 +219,13 @@ class SwidgetDevice:
 
         :raises SwidgetException: Raise the exception if there we are unable to connect to the Swidget device
         """
+        _LOGGER.debug("SwidgetDevice.ping() called")
         try:
             async with self._session.get(
-                url=f"https://{self.ip_address}/ping",
-                ssl=self.ssl
+                url=f"{self.uri_scheme}://{self.ip_address}/ping",
+                ssl=False
             ) as response:
-                return response.text
+                return response.status
         except:
             raise SwidgetException
 
@@ -179,12 +234,13 @@ class SwidgetDevice:
 
         :raises SwidgetException: Raise the exception if there we are unable to connect to the Swidget device
         """
+        _LOGGER.debug("SwidgetDevice.blink() called")
         try:
             async with self._session.get(
-                url=f"https://{self.ip_address}/blink",
-                ssl=self.ssl
+                url=f"{self.uri_scheme}://{self.ip_address}/blink",
+                ssl=False
             ) as response:
-                return response.text
+                return await response.json()
         except:
             raise SwidgetException
 
@@ -193,12 +249,13 @@ class SwidgetDevice:
 
         :raises SwidgetException: Raise the exception if there we are unable to connect to the Swidget device
         """
+        _LOGGER.debug("SwidgetDevice.enable_debug_server() called")
         try:
             async with self._session.get(
-                url=f"https://{self.ip_address}/debug?x-secret-key={self.secret_key}",
-                ssl=self.ssl
+                url=f"{self.uri_scheme}://{self.ip_address}/debug?x-secret-key={self.secret_key}",
+                ssl=False
             ) as response:
-                return response.text
+                return await response.json()
         except:
             raise SwidgetException
 
@@ -210,10 +267,43 @@ class SwidgetDevice:
         try:
 
             async with self._session.delete(
-                url=f"https://{self.ip_address}/api/v1/reset",
-                ssl=self.ssl
+                url=f"{self.uri_scheme}://{self.ip_address}/api/v1/reset",
+                ssl=False
             ) as response:
-                return response.text
+                return await response.json()
+        except:
+            raise SwidgetException
+
+    async def check_for_updates(self):
+        """Tell the device to contact the Swidget servers to see if there is an available update
+
+        :raises SwidgetException: Raise the exception if there we are unable to connect to the Swidget device
+        """
+        try:
+
+            async with self._session.get(
+                url=f"{self.uri_scheme}://{self.ip_address}/api/v1/update",
+                ssl=False
+            ) as response:
+                return await response.json()
+        except:
+            raise SwidgetException
+
+    async def update_version(self, version):
+        """Tell the device to download and apply an update
+
+        :raises SwidgetException: Raise the exception if there we are unable to connect to the Swidget device
+        """
+        try:
+            data = {
+                "version": version
+            }
+            async with self._session.post(
+                url=f"{self.uri_scheme}://{self.ip_address}/api/v1/update",
+                ssl=False,
+                data=json.dumps(data)
+            ) as response:
+                return await response
         except:
             raise SwidgetException
 
@@ -329,7 +419,7 @@ class SwidgetDevice:
     @property
     def is_dimmable(self) -> bool:
         """Return  True if the device is dimmable."""
-        return False
+        return self.is_dimmer
 
     @property  # type: ignore
     def friendly_name(self) -> str:
@@ -346,11 +436,14 @@ class SwidgetDevice:
 
     async def turn_on(self):
         """Turn the device on."""
+        _LOGGER.debug("SwidgetDevice.turn_on() called")
         await self.send_command(
             assembly="host", component="0", function="toggle", command={"state": "on"}
         )
+
     async def turn_off(self):
         """Turn the device off."""
+        _LOGGER.debug("SwidgetDevice.turn_off() called")
         await self.send_command(
             assembly="host", component="0", function="toggle", command={"state": "off"}
         )

{python_swidget-0.0.32 → python_swidget-1.0.1}/swidget/swidgetdimmer.py

@@ -6,14 +6,13 @@ from swidget.swidgetdevice import (
 )
 from swidget.exceptions import SwidgetException
 
+_LOGGER = logging.getLogger(__name__)
 
 
-log = logging.getLogger(__name__)
-
 class SwidgetDimmer(SwidgetDevice):
 
-    def __init__(self, host,  token_name: str, secret_key: str, ssl: bool, use_websockets: bool) -> None:
-        super().__init__(host=host, token_name=token_name, secret_key=secret_key, ssl=ssl, 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 = "dimmer"
 
     @property  # type: ignore
@@ -31,11 +30,13 @@ class SwidgetDimmer(SwidgetDevice):
 
     async def set_brightness(self, brightness):
         """Set the brightness of the device."""
+        _LOGGER.debug("SwidgetDimmer.set_brightness() called")
         await self.send_command(
             assembly="host", component="0", function="level", command={"now": brightness}
         )
 
     async def set_default_brightness(self, brightness):
+        _LOGGER.debug("SwidgetDimmer.set_default_brightness() called")
         await self.send_command(
             assembly="host", component="0", function="level", command={"default": brightness}
         )

{python_swidget-0.0.32 → python_swidget-1.0.1}/swidget/swidgetoutlet.py

@@ -6,6 +6,6 @@ from swidget.swidgetdevice import (
 
 class SwidgetOutlet(SwidgetDevice):
 
-    def __init__(self, host,  token_name: str, secret_key: str, ssl: bool, use_websockets: bool) -> None:
-        super().__init__(host=host, token_name=token_name, secret_key=secret_key, ssl=ssl, 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.Outlet

{python_swidget-0.0.32 → python_swidget-1.0.1}/swidget/swidgetswitch.py

@@ -6,8 +6,8 @@ from swidget.swidgetdevice import (
 
 class SwidgetSwitch(SwidgetDevice):
 
-    def __init__(self, host,  token_name: str, secret_key: str, ssl: bool, use_websockets: bool) -> None:
-        super().__init__(host=host, token_name=token_name, secret_key=secret_key, ssl=ssl, 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.Switch
 
     async def current_consumption(self) -> float:

{python_swidget-0.0.32 → python_swidget-1.0.1}/swidget/swidgettimerswitch.py

@@ -1,17 +1,21 @@
+import logging
 from swidget.swidgetdevice import (
     DeviceType,
 )
 from swidget.swidgetswitch import SwidgetSwitch
 
+_LOGGER = logging.getLogger(__name__)
+
 
 class SwidgetTimerSwitch(SwidgetSwitch):
 
-    def __init__(self, host,  token_name: str, secret_key: str, ssl: bool, use_websockets: bool) -> None:
-        super().__init__(host=host, token_name=token_name, secret_key=secret_key, ssl=ssl, 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):
         """Set the countdown timer."""
+        _LOGGER.debug("SwidgetTimerSwitch.set_brightness() called")
         await self.send_command(
             assembly="host", component="0", function="timer", command={"duration": minutes}
         )

python_swidget-1.0.1/swidget/websocket.py

@@ -0,0 +1,123 @@
+import asyncio
+import aiohttp
+from aiohttp import ClientWebSocketResponse, WSMsgType
+import logging
+import socket
+
+_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.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 self._client is not None and not self._client.closed
+
+    @property
+    def websocket(self) -> ClientWebSocketResponse | None:
+        """Return the web socket."""
+        return self._ws
+
+    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:
+        _LOGGER.debug("websocket.connect() called")
+        """Create a new connection and, optionally, start the monitor."""
+        await cancel_task(self._receiver_task)
+        if self.connected:
+            _LOGGER.debug("Websocket already connected")
+            return
+
+        if not self.session:
+            raise
+
+        try:
+            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,
+            aiohttp.ClientConnectionError,
+            socket.gaierror,
+        ) as exception:
+            msg = (
+                "Error occurred while communicating with WLED device"
+                f" on WebSocket at {self.host}"
+            )
+            raise(msg)
+        self._receiver_task = asyncio.ensure_future(self.listen())
+
+    async def close(self) -> None:
+        _LOGGER.debug("websocket.close() called")
+        if not self._client or not self.connected:
+            return
+        await self._client.close()
+
+    async def send_str(self, message):
+        """Send a message through the websocket."""
+        _LOGGER.debug("websocket.send_str() called")
+        message = str(message)
+        _LOGGER.debug(f"Sending messsage over websocket: {message}")
+        await self._client.send_str(f'{message}')
+
+    async def listen(self):
+        _LOGGER.debug("websocket.listen() called")
+        if not self._client or not self.connected:
+            raise
+
+        while not self._client.closed:
+            message = await self._client.receive()
+
+            if message.type == aiohttp.WSMsgType.ERROR:
+                raise
+
+            if message.type == aiohttp.WSMsgType.TEXT:
+                message_data = message.json()
+                await self.callback(message_data)
+
+            if message.type in (
+                aiohttp.WSMsgType.CLOSE,
+                aiohttp.WSMsgType.CLOSED,
+                aiohttp.WSMsgType.CLOSING,
+            ):
+                _LOGGER.debug("Connection to the Swidget WebSocket on has been closed")

python_swidget-0.0.32/README.md

@@ -1,2 +0,0 @@
-# python-swidget
-A library to manage Swidget smart devices

python_swidget-0.0.32/swidget/websocket.py

@@ -1,124 +0,0 @@
-import aiohttp
-import asyncio
-import logging
-import json
-
-
-
-_LOGGER = logging.getLogger(__name__)
-
-ERROR_AUTH_FAILURE = "Authorization failure"
-ERROR_TOO_MANY_RETRIES = "Too many retries"
-ERROR_UNKNOWN = "Unknown"
-
-MAX_FAILED_ATTEMPTS = 5
-
-STATE_CONNECTED = "connected"
-STATE_DISCONNECTED = "disconnected"
-STATE_STARTING = "starting"
-STATE_STOPPED = "stopped"
-
-
-class SwidgetWebsocket:
-    """A websocket connection to a Swidget Device"""
-
-    # pylint: disable=too-many-instance-attributes
-
-    def __init__(
-        self,
-        host,
-        token_name,
-        secret_key,
-        callback,
-        session=None,
-        verify_ssl=False,
-    ):
-
-        self.session = session or aiohttp.ClientSession()
-        self.uri = self._get_uri(host, token_name, secret_key)
-        self.callback = callback
-        self._ssl = False if verify_ssl is False else None
-        self._state = None
-        self.failed_attempts = 0
-        self._error_reason = None
-
-    @property
-    def state(self):
-        """Return the current state."""
-        return self._state
-
-    @state.setter
-    def state(self, value):
-        """Set the state."""
-        self._state = value
-
-    @staticmethod
-    def _get_uri(host, token_name, secret_key):
-        """Generate the websocket URI"""
-        return f"wss://{host}/api/v1/sock?{token_name}={secret_key}"
-
-    async def running(self):
-        """Open a persistent websocket connection and act on events."""
-        self.state = STATE_STARTING
-
-        try:
-            headers = {'Connection': 'Upgrade'}
-            async with self.session.ws_connect(self.uri, headers=headers, verify_ssl=False, heartbeat=30) as self.ws_client:
-                self.state = STATE_CONNECTED
-                self.failed_attempts = 0
-                await self.send_str(json.dumps({"type": "summary", "request_id": "1"}))
-                await self.send_str(json.dumps({"type": "state", "request_id": "2"}))
-                async for message in self.ws_client:
-                    if self.state == STATE_STOPPED:
-                        break
-                    if message.type == aiohttp.WSMsgType.TEXT:
-                        msg = message.json()
-                        await self.callback(msg)
-
-                    elif message.type == aiohttp.WSMsgType.CLOSED:
-                        break
-
-                    elif message.type == aiohttp.WSMsgType.ERROR:
-                        break
-        except aiohttp.ClientResponseError as error:
-            if error.code == 401:
-                _LOGGER.error(f"Credentials rejected: {error}")
-                self._error_reason = ERROR_AUTH_FAILURE
-            else:
-                _LOGGER.error(f"Unexpected response received: {error}")
-                self._error_reason = ERROR_UNKNOWN
-            self.state = STATE_STOPPED
-        except (aiohttp.ClientConnectionError, asyncio.TimeoutError) as error:
-            if self.failed_attempts >= MAX_FAILED_ATTEMPTS:
-                self._error_reason = ERROR_TOO_MANY_RETRIES
-                self.state = STATE_STOPPED
-            elif self.state != STATE_STOPPED:
-                retry_delay = min(2 ** (self.failed_attempts - 1) * 30, 300)
-                self.failed_attempts += 1
-                self.state = STATE_DISCONNECTED
-                await asyncio.sleep(retry_delay)
-        except Exception as error:  # pylint: disable=broad-except
-            if self.state != STATE_STOPPED:
-                _LOGGER.error(f"Unexpected exception occurred: {error}")
-                self._error_reason = ERROR_UNKNOWN
-                self.state = STATE_STOPPED
-        else:
-            if self.state != STATE_STOPPED:
-                self.state = STATE_DISCONNECTED
-                await asyncio.sleep(5)
-
-    async def send_str(self, message):
-        message = str(message)
-        await self.ws_client.send_str(f'{message}')
-
-    async def listen(self):
-        """Close the listening websocket."""
-        self.failed_attempts = 0
-        while self.state != STATE_STOPPED:
-            await self.running()
-
-    async def close(self):
-        """Close the listening websocket."""
-        self.state = STATE_STOPPED
-        if self.ws_client:
-            await self.ws_client.close()