python-swidget 0.0.31__tar.gz → 1.0.0__tar.gz

{python_swidget-0.0.31 → python_swidget-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-swidget
-Version: 0.0.31
+Version: 1.0.0
 Summary: Python API for Swidget smart devices
 Home-page: https://github.com/swidget/python-swidget
 License: GPL-3.0-or-later
@@ -12,6 +12,7 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Provides-Extra: docs
 Requires-Dist: aiohttp (>=3.8.1)
 Requires-Dist: anyio
@@ -30,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.0/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.31 → python_swidget-1.0.0}/pyproject.toml

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

{python_swidget-0.0.31 → python_swidget-1.0.0}/swidget/__init__.py

@@ -15,6 +15,7 @@ from importlib_metadata import version  # type: ignore
 
 from swidget.discovery import discover_devices, discover_single, SwidgetDiscoveredDevice
 from swidget.exceptions import SwidgetException
+from swidget.provision import provision_wifi
 from swidget.swidgetdevice import DeviceType, SwidgetAssembly, SwidgetDevice, SwidgetComponent
 from swidget.swidgetdimmer import SwidgetDimmer
 from swidget.swidgetoutlet import SwidgetOutlet
@@ -28,6 +29,7 @@ __version__ = version("python-swidget")
 __all__ = [
     "discover_devices",
     "discover_single",
+    "provision_wifi"
     "SwidgetDiscoveredDevice",
     "SwidgetException",
     "DeviceType",

{python_swidget-0.0.31 → python_swidget-1.0.0}/swidget/cli.py

@@ -1,15 +1,16 @@
 """python-swidget cli tool."""
-import asyncio
 import logging
 import sys
 from pprint import pformat as pf
 from typing import cast
 
 import asyncclick as click
+from contextlib import asynccontextmanager
 
 from swidget import (
     discover_devices,
     discover_single,
+    provision_wifi,
     SwidgetDevice,
     SwidgetDimmer,
     SwidgetSwitch,
@@ -31,14 +32,12 @@ pass_dev = click.make_pass_decorator(SwidgetDevice)
 
 
 @click.group(invoke_without_command=True)
-@click.option(
-    "--host",
+@click.option("--host",
     envvar="SWIDGET_HOST",
     required=False,
     help="The host name or IP address of the device to connect to.",
 )
-@click.option(
-    "--password",
+@click.option("-p", "--password",
     envvar="SWIDGET_PASSWORD",
     required=False,
     help="The password of the device to connect to.",
@@ -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,12 +58,10 @@ 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":
-        # Context object is required to avoid crashing on sub-groups
-        ctx.obj = SwidgetDevice(None)
         return
 
     if debug:
@@ -68,54 +69,61 @@ async def cli(ctx, host, password, debug, type):
     else:
         logging.basicConfig(level=logging.INFO)
 
-    if ctx.invoked_subcommand == "discover":
+    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)
         return
-
     if type is not None:
         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..")
+        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()
 
-    await dev.update()
-    ctx.obj = dev
+    @asynccontextmanager
+    async def async_wrapped_device(dev: SwidgetDevice):
+        try:
+            yield dev
+        finally:
+            await dev.stop()
+
+    ctx.obj = await ctx.with_async_resource(async_wrapped_device(dev))
 
     if ctx.invoked_subcommand is None:
-        await ctx.invoke(state)
+        return await ctx.invoke(state)
 
 
 @cli.group()
-@pass_dev
-def wifi(dev):
+def wifi():
     """Commands to control wifi settings."""
 
+
 @wifi.command()
-@click.argument("ssid")
-@click.option("--password", prompt=True, hide_input=True)
-@click.option("--keytype", default=3)
-@pass_dev
-async def join(dev: SwidgetDevice, ssid, password, keytype):
+@click.option("--ssid", prompt=True, hide_input=False)
+@click.option("--network_password", prompt=True, hide_input=True)
+@click.option("--secret_key", prompt=True, hide_input=True)
+@click.option("--friendly_name", prompt=True, hide_input=False)
+def join(ssid, network_password, secret_key, friendly_name):
     """Join the given wifi network."""
-    click.echo(f"Asking the device to connect to {ssid}..")
-    res = await dev.wifi_join(ssid, password, keytype=keytype)
-    click.echo(
-        f"Response: {res} - if the device is not able to join the network, it will revert back to its previous state."
-    )
-
-    return res
+    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)
+        return True
+    else:
+        click.echo("Not provisioning wifi")
+        return False
 
 
 @cli.command()
@@ -158,7 +166,8 @@ 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))
-    for info_name, info_data in dev.realtime_values.items():
+    realtime_values = await dev.realtime_values
+    for info_name, info_data in realtime_values.items():
         if isinstance(info_data, list):
             click.echo(f"\t{info_name}:")
             for item in info_data:
@@ -176,7 +185,6 @@ async def state(dev: SwidgetDevice):
         click.echo(click.style(f"\t+ {function}", fg="green"))
 
 
-
 @cli.command()
 @pass_dev
 @click.argument("assembly")
@@ -196,7 +204,6 @@ async def raw_command(dev: SwidgetDevice, assembly, component, function, command
     return res
 
 
-
 @cli.command()
 @click.argument("brightness", type=click.IntRange(0, 100), default=None, required=False)
 @pass_dev
@@ -221,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):
@@ -237,5 +258,42 @@ async def off(dev: SwidgetDevice):
     return await dev.turn_off()
 
 
+@cli.command()
+@pass_dev
+async def enable_debug_server(dev: SwidgetDevice):
+    """Enable Debug Server"""
+    click.echo(f"Enabling debug server")
+    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.31 → python_swidget-1.0.0}/swidget/discovery.py

@@ -39,6 +39,10 @@ class SwidgetProtocol(ssdp.SimpleServiceDiscoveryProtocol):
             insert_type = headers["SERVER"].split(" ")[1].split("+")[1].split("/")[0]
             friendly_name = headers["SERVER"].split("/")[2].strip('"')
             devices[mac_address] = SwidgetDiscoveredDevice(mac_address, ip_address, friendly_name)
+<<<<<<< HEAD
+=======
+            _LOGGER.debug(f"Swidget device '{friendly_name}' at {ip_address}")
+>>>>>>> 690a0c560a8b2ff39245d1a8354ced968d79e5de
 
 
 async def discover_devices(timeout=RESPONSE_SEC):
@@ -64,19 +68,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, False, 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-1.0.0/swidget/provision.py

@@ -0,0 +1,116 @@
+from enum import Enum
+import time
+
+import requests
+import urllib3
+
+urllib3.disable_warnings()
+
+
+class DeviceConnectionResult(str, Enum):
+    NoStarted = "NotInitiated",
+    InProgress ="AttemptingConnect",
+    Success = "Success",
+    AuthenticationFailure = "AuthFail",
+    SSIDNotFound = "SSIDNotFound",
+    NoIp = "NoIpReceived",
+    ConnectionFailure = "FailedToConnect"
+
+
+def send_credentials(device_name, ssid, network_password, secret_key):
+    payload = {"name": device_name,
+               "ssid": ssid,
+               "password": network_password,
+               "secretKey": secret_key}
+    url = "https://10.123.45.1/network"
+    sentProvisionRequestAttempts = 0
+
+    while True:
+        print(f"Provision Attempt: {sentProvisionRequestAttempts}")
+        if sentProvisionRequestAttempts >= 5:
+            print(f"Provision failed, Ensure you're connected to the device's hotspot.")
+            return False, None
+        try:
+            initial_provision = requests.post(url, json=payload, verify=False)
+            if initial_provision.status_code == 200:
+                print(f"Provision Success")
+                return True, initial_provision.json()["secretKey"]
+            else:
+                print(f"Provision Failed: {initial_provision.json()}")
+                return False, None
+        except Exception as e:
+            print("Error", e)
+            time.sleep(5)
+            sentProvisionRequestAttempts += 1
+
+
+def verify_connect_result(key):
+    headers = {'x-secret-key': key}
+    connect_success = False
+    connect_verification_attempts = 0
+    while not connect_success:
+        url = "https://10.123.45.1/network"
+        if connect_verification_attempts >= 5:
+            return False, None, None, "Failed to connect to device"
+        try:
+            verify_connection = requests.get(url, headers=headers, verify=False)
+            print(f"Verify Response: {verify_connection.json()}")
+            if verify_connection.status_code == 200:
+                print(f"Verification request success: {verify_connection.json()}")
+                connect_status = verify_connection.json()["status"]
+                if connect_status == DeviceConnectionResult.Success:
+                    return True, verify_connection.json()["ip"], verify_connection.json()["mac"], None
+                elif connect_status == DeviceConnectionResult.InProgress:
+                    pass
+                else:
+                    return False, None, None, connect_status
+            else:
+                print(f"Verification request failure: {verify_connection.json()}")
+            time.sleep(5)
+        except:
+            time.sleep(5)
+            connect_verification_attempts += 1
+
+
+def provision_wifi(device_name, ssid, network_password, secret_key):
+    print(f"Device_name: {device_name}")
+    print(f"SSID: {ssid}")
+    print(f"Network Password: <redacted>")
+    print(f"Swidget Secret Key: <redacted>")
+
+    send_success, key = send_credentials(device_name, ssid, network_password, secret_key)
+    if not send_success:
+        return False
+    secret_key = key # we set the key to whatever was returned from the device. this handles the case of an empty string (which causes insert to generate a key)
+
+    verify_success, ip, mac, errorMessage = verify_connect_result(secret_key)
+    if not verify_success:
+        print(f"Verify Error: {errorMessage}")
+        return False
+    print(f"Verified Connection: {ip} {mac}")
+    headers = {'x-secret-key': secret_key}
+    # the device will remain in AP mode for 60 seconds before switching over to control mode. This is to allow time to send requests to update the device
+    # without swiching networks.
+
+    # issuing the setup_complete request will skip the 60s time
+    complete_setup = requests.get("https://10.123.45.1/setup_complete", headers=headers, verify=False)
+    if complete_setup.status_code == 200:
+        print("Setup complete, enabled control server")
+    else:
+        return False
+
+    #alternatively, sleep for some time
+    print("Device has been configured, switch your wifi network off `Swidget-` now")
+    time.sleep(30)
+
+    # must connect to the main network before issuing control requests
+    getNameSuccess = False
+    while not getNameSuccess:
+        try:
+            url = f"https://{ip}/api/v1/name"
+            verify_name = requests.get(url, headers=headers, verify=False).json()
+            print(f"Verifying device name has been set: {verify_name}. Provisioning complete")
+            return True
+        except:
+            print("Connect to provided network")
+        time.sleep(5)

{python_swidget-0.0.31 → python_swidget-1.0.0}/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,19 @@ 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(force_close=True)
+        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,33 +48,62 @@ 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()
 
-    def stop(self):
+    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._websocket.listen() ")
+            asyncio.create_task(self._websocket.listen())
+
+    async def stop(self):
         """Stop the websocket."""
-        if self._websocket is not None:
-            self._websocket.stop()
+        _LOGGER.debug("SwidgetDevice.stop()")
+        if hasattr(self, '_websocket'):
+            await self._websocket.close()
+        await self._session.close()
 
     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"""
-        async with self._session.get(
-            url=f"https://{self.ip_address}/api/v1/summary", ssl=self.ssl
-        ) as response:
-            summary = await response.json()
-        await self.process_summary(summary)
+        _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"{self.uri_scheme}://{self.ip_address}/api/v1/summary", ssl=False
+            ) as response:
+                summary = await response.json()
+            await self.process_summary(summary)
 
     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"]
@@ -85,9 +117,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:
@@ -95,24 +128,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:
@@ -122,36 +164,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()
-        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
 
@@ -160,12 +215,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
 
@@ -174,12 +230,76 @@ 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
+
+    async def enable_debug_server(self):
+        """Enable the Swidget local debug server
+
+        :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"{self.uri_scheme}://{self.ip_address}/debug?x-secret-key={self.secret_key}",
+                ssl=False
+            ) as response:
+                return await response.json()
+        except:
+            raise SwidgetException
+
+    async def factory_reset(self):
+        """Factory reset the Swidget device
+
+        :raises SwidgetException: Raise the exception if there we are unable to connect to the Swidget device
+        """
+        try:
+
+            async with self._session.delete(
+                url=f"{self.uri_scheme}://{self.ip_address}/api/v1/reset",
+                ssl=False
+            ) as response:
+                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
 
@@ -202,7 +322,7 @@ class SwidgetDevice:
             "rssi": self.rssi
         }
 
-    def get_child_consumption(self, plug_id=0):
+    async def get_child_consumption(self, plug_id=0):
         """Get the power consumption of a plug in watts."""
         if plug_id == "all":
             return_dict = {}
@@ -222,7 +342,7 @@ class SwidgetDevice:
         return total_consumption
 
     @property
-    def realtime_values(self):
+    async def realtime_values(self):
         """Get a dict of realtime value attributes from the insert and host
 
         :return: A dictionary of insert sensor values and power consumption values
@@ -232,7 +352,7 @@ class SwidgetDevice:
         for feature in self.insert_features:
             return_dict.update(self.get_function_values(feature))
         return_dict.update({'rssi': self.rssi})
-        power_values = self.get_child_consumption("all")
+        power_values = await self.get_child_consumption("all")
         if power_values:
             return_dict.update(power_values)
         return return_dict
@@ -295,7 +415,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:
@@ -312,11 +432,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"}
         )
@@ -346,10 +469,6 @@ class SwidgetDevice:
             return f"<{self.device_type} at {self.ip_address} - update() needed>"
         return f"<{self.device_type} model {self.model} at {self.ip_address}>"
 
-    def __del__(self):
-        if self.use_websockets:
-            self.stop()
-
 
 class SwidgetAssembly:
     def __init__(self, summary: dict):
@@ -363,4 +482,4 @@ class SwidgetAssembly:
 
 class SwidgetComponent:
     def __init__(self, functions):
-        self.functions = {f: None for f in functions}
+        self.functions = {f: None for f in functions}

{python_swidget-0.0.31 → python_swidget-1.0.0}/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.31 → python_swidget-1.0.0}/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.31 → python_swidget-1.0.0}/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.31 → python_swidget-1.0.0}/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.0/swidget/websocket.py

@@ -0,0 +1,99 @@
+import aiohttp
+import logging
+import socket
+
+_LOGGER = logging.getLogger(__name__)
+
+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'}
+
+    @property
+    def connected(self) -> bool:
+        return self._client is not None and not self._client.closed
+
+    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")
+        if self.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)
+        except (
+            aiohttp.WSServerHandshakeError,
+            aiohttp.ClientConnectionError,
+            socket.gaierror,
+        ) as exception:
+            msg = (
+                "Error occurred while communicating with WLED device"
+                f" on WebSocket at {self.host}"
+            )
+            raise
+
+    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()
+                _LOGGER.debug(f"Data received from websocket: {message_data}")
+                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.31/README.md

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

python_swidget-0.0.31/swidget/provision.py

@@ -1,16 +0,0 @@
-import time
-
-import requests
-
-
-def provision_wifi(ssid, network_password, token_name, secret_key):
-    payload = {"ssid": ssid, "password": network_password, "secretKey": secret_key}
-    headers = {token_name: secret_key}
-    url = "https://10.123.45.1/network"
-    initial_provision = requests.post(url, data=payload, verify=False).json()
-    print(f"Response from setting {initial_provision}")
-
-    time.sleep(5)
-    url = "https://10.123.45.1/network"
-    verify_connection = requests.get(url, headers=headers, verify=False).json()
-    print(f"Verification request data: {verify_connection}")

python_swidget-0.0.31/swidget/websocket.py

@@ -1,128 +0,0 @@
-import asyncio
-from datetime import datetime
-import logging
-import json
-
-import aiohttp
-
-_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
-                self.send_str(json.dumps({"type": "summary", "request_id": "1"}))
-                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()
-
-    def close(self):
-        """Close the listening websocket."""
-        self.state = STATE_STOPPED
-        self.ws_client.close()