python-swidget 1.2.2__tar.gz → 1.2.3__tar.gz

{python_swidget-1.2.2 → python_swidget-1.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-swidget
-Version: 1.2.2
+Version: 1.2.3
 Summary: Python API for Swidget smart devices
 Home-page: https://github.com/swidget/python-swidget
 License: GPL-3.0-or-later
@@ -52,3 +52,4 @@ A library to manage Swidget smart devices
     dev.turn_on()
     dev.close()
 ```
+

{python_swidget-1.2.2 → python_swidget-1.2.3}/README.md

@@ -18,4 +18,4 @@ A library to manage Swidget smart devices
     dev.update()
     dev.turn_on()
     dev.close()
-```
+```

{python_swidget-1.2.2 → python_swidget-1.2.3}/pyproject.toml

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

{python_swidget-1.2.2 → python_swidget-1.2.3}/swidget/__init__.py

@@ -11,25 +11,30 @@ For device type specific actions `SwidgetDimmer`, `SwidgetOutlet`, or `SwidgetSw
 Module-specific errors are raised as `SwidgetException` and are expected
 to be handled by the user of the library.
 """
+
 from importlib_metadata import version  # type: ignore
 
-from swidget.discovery import discover_devices, discover_single, SwidgetDiscoveredDevice
+from swidget.discovery import SwidgetDiscoveredDevice, discover_devices, discover_single
 from swidget.exceptions import SwidgetException
 from swidget.provision import provision_wifi
-from swidget.swidgetdevice import DeviceType, SwidgetAssembly, SwidgetDevice, SwidgetComponent
+from swidget.swidgetdevice import (
+    DeviceType,
+    SwidgetAssembly,
+    SwidgetComponent,
+    SwidgetDevice,
+)
 from swidget.swidgetdimmer import SwidgetDimmer
 from swidget.swidgetoutlet import SwidgetOutlet
 from swidget.swidgetswitch import SwidgetSwitch
 from swidget.swidgettimerswitch import SwidgetTimerSwitch
 
-
 __version__ = version("python-swidget")
 
 
 __all__ = [
     "discover_devices",
     "discover_single",
-    "provision_wifi"
+    "provision_wifi",
     "SwidgetDiscoveredDevice",
     "SwidgetException",
     "DeviceType",
@@ -40,4 +45,4 @@ __all__ = [
     "SwidgetOutlet",
     "SwidgetSwitch",
     "SwidgetTimerSwitch",
-]
+]

{python_swidget-1.2.2 → python_swidget-1.2.3}/swidget/cli.py

@@ -1,28 +1,29 @@
 """python-swidget cli tool."""
+
 import logging
 import sys
-from typing import Any, cast
+from contextlib import asynccontextmanager
 from pprint import pformat as pf
+from typing import Any, cast
 
 import asyncclick as click
-from contextlib import asynccontextmanager
 
 from swidget import (
-    discover_devices,
-    discover_single,
-    provision_wifi,
     SwidgetDevice,
     SwidgetDimmer,
-    SwidgetSwitch,
     SwidgetOutlet,
-    SwidgetTimerSwitch
+    SwidgetSwitch,
+    SwidgetTimerSwitch,
+    discover_devices,
+    discover_single,
+    provision_wifi,
 )
 
 TYPE_TO_CLASS = {
     "dimmer": SwidgetDimmer,
     "switch": SwidgetSwitch,
     "outlet": SwidgetOutlet,
-    "pana_switch": SwidgetTimerSwitch
+    "pana_switch": SwidgetTimerSwitch,
 }
 
 
@@ -30,24 +31,23 @@ 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("-p", "--password",
+@click.option(
+    "-p",
+    "--password",
     envvar="SWIDGET_PASSWORD",
     required=False,
     help="The password of the device to connect to.",
 )
-@click.option("-d", "--debug",
-    envvar="SWIDGET_DEBUG",
-    default=False,
-    is_flag=True)
-@click.option("--http_only",
-    envvar="SWIDGET_HTTP_ONLY",
-    default=True,
-    is_flag=True)
+@click.option("-d", "--debug", envvar="SWIDGET_DEBUG", default=False, is_flag=True)
+@click.option(
+    "-ho", "--http_only", envvar="SWIDGET_HTTP_ONLY", default=True, is_flag=True
+)
 @click.option(
     "--type",
     envvar="SWIDGET_TYPE",
@@ -74,18 +74,22 @@ async def cli(ctx, host, password, debug, http_only, type):
         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,
-                                  use_https=http_only,
-                                  use_websockets=False)
+        dev = TYPE_TO_CLASS[type](
+            host=host,
+            token_name="x-secret-key",
+            secret_key=password,
+            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,
-                                    use_https=http_only,
-                                    use_websockets=False)
+        dev = await discover_single(
+            host=host,
+            token_name="x-secret-key",
+            password=password,
+            use_https=http_only,
+            use_websockets=False,
+        )
         await dev.update()
 
     @asynccontextmanager
@@ -113,11 +117,15 @@ def wifi():
 @click.option("--friendly_name", prompt=True, hide_input=False)
 def join(ssid, network_password, secret_key, friendly_name):
     """Join the given wifi network."""
-    confirmation = click.prompt(f"Are you connected to a wifi network that stars with the name 'Swidget-' (y/n)")
+    confirmation = click.prompt(
+        "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}..")
         provision_wifi(friendly_name, ssid, network_password, secret_key)
-        click.echo(f"Disconnect from the `swidget` network and connect back your main WiFi network")
+        click.echo(
+            "Disconnect from the 'swidget' network and connect back your main WiFi network"
+        )
         return True
     else:
         click.echo("Not provisioning wifi")
@@ -135,6 +143,7 @@ async def discover(ctx, timeout):
     for device in devices.values():
         click.echo(f"{device.host}[{device.mac}] - {device.friendly_name}")
 
+
 @cli.command()
 @pass_dev
 async def hwinfo(dev):
@@ -149,7 +158,7 @@ async def hwinfo(dev):
 async def state(dev: SwidgetDevice):
     """Print out device state and versions."""
     click.echo(click.style(f"== {dev.friendly_name} - {dev.model} ==", bold=True))
-    click.echo(f"\tFriendly Name:  {dev.friendly_name}")
+    click.echo(f"\tFriendly Name: {dev.friendly_name}")
     click.echo(f"\tHost: {dev.ip_address}")
     click.echo(
         click.style(
@@ -159,9 +168,9 @@ async def state(dev: SwidgetDevice):
     )
 
     click.echo(click.style("\t== Generic information ==", bold=True))
-    click.echo(f"\tHardware:     {dev.hw_info['model']}")
-    click.echo(f"\tSoftware:     {dev.hw_info['version']}")
-    click.echo(f"\tMAC (rssi):   {dev.mac_address} ({dev.rssi})")
+    click.echo(f"\tHardware: {dev.hw_info['model']}")
+    click.echo(f"\tSoftware: {dev.hw_info['version']}")
+    click.echo(f"\tMAC (rssi): {dev.mac_address} ({dev.rssi})")
 
     click.echo(click.style("\n\t== Current State ==", bold=True))
     realtime_values = dev.realtime_values
@@ -177,7 +186,6 @@ async def state(dev: SwidgetDevice):
     for function in dev.host_features:
         click.echo(click.style(f"\t+ {function}", fg="green"))
 
-
     click.echo(click.style("\n\t== Insert Features ==", bold=True))
     for function in dev.insert_features:
         click.echo(click.style(f"\t+ {function}", fg="green"))
@@ -198,7 +206,8 @@ async def raw_command(dev: SwidgetDevice, assembly, component, function, command
 @cli.command()
 @click.argument("brightness", type=click.IntRange(0, 100), default=None, required=False)
 @pass_dev
-async def brightness(dev: SwidgetDevice, brightness: Any=None):
+async def brightness(dev: SwidgetDevice, brightness: Any = None):
+    """Get or set the brightness of a dimmer device."""
     dimmer_dev = cast(SwidgetDimmer, dev)
     """Get or set brightness."""
     if not dimmer_dev.is_dimmer:
@@ -215,25 +224,26 @@ async def brightness(dev: SwidgetDevice, brightness: Any=None):
 @cli.command()
 @pass_dev
 async def blink(dev):
-    """Set the device insert to blink"""
-    click.echo(f"Requesting the device to blink")
+    """Set the device insert to blink."""
+    click.echo("Requesting the device to blink")
     return await dev.blink()
 
 
 @cli.command()
 @pass_dev
 async def ping(dev):
-    """Ping the device"""
-    click.echo(f"Pinging the device")
+    """Ping the device."""
+    click.echo("Pinging the device")
     try:
         result = await dev.ping()
         if result == 200:
             click.echo("Successfully pinged device")
         else:
             click.echo(result.status_code)
-    except:
+    except Exception:
         click.echo("Unable to ping device")
 
+
 @cli.command()
 @pass_dev
 async def on(dev: SwidgetDevice):
@@ -253,14 +263,15 @@ async def off(dev: SwidgetDevice):
 @cli.command()
 @pass_dev
 async def enable_debug_server(dev: SwidgetDevice):
-    """Enable Debug Server"""
-    click.echo(f"Enabling debug server")
+    """Enable Debug Server."""
+    click.echo("Enabling debug server")
     return await dev.enable_debug_server()
 
 
 @cli.command()
 @pass_dev
 async def check_for_updates(dev: SwidgetDevice):
+    """Connect to Swidget Cloud to see if there are any updates available for the insert."""
     click.echo("Contacting Swidget servers to fetch for updates...")
     available_updates = await dev.check_for_updates()
     if len(available_updates) == 0:
@@ -275,6 +286,7 @@ async def check_for_updates(dev: SwidgetDevice):
 @click.option("--version", required=False)
 @pass_dev
 async def upgrade(dev: SwidgetDevice, version: str):
+    """Update the device to a newer version."""
     if version is None:
         click.echo("Contacting Swidget servers to fetch for latest version")
         available_updates = await dev.check_for_updates()

{python_swidget-1.2.2 → python_swidget-1.2.3}/swidget/discovery.py

@@ -1,3 +1,4 @@
+"""Module to discover Swidget devices."""
 import asyncio
 import logging
 import socket
@@ -7,11 +8,12 @@ from urllib.parse import urlparse
 import ssdp  # type: ignore
 
 from swidget.swidgetdevice import DeviceType, SwidgetDevice
+
+from .exceptions import SwidgetException
 from .swidgetdimmer import SwidgetDimmer
 from .swidgetoutlet import SwidgetOutlet
 from .swidgetswitch import SwidgetSwitch
 from .swidgettimerswitch import SwidgetTimerSwitch
-from .exceptions import SwidgetException
 
 RESPONSE_SEC = 5
 SWIDGET_ST = "urn:swidget:pico:1"
@@ -20,16 +22,28 @@ devices = dict()
 
 
 class SwidgetDiscoveredDevice:
-    def __init__(self, mac: str, host: str, friendly_name: str = "Swidget Discovered Device"):
+    """Stub class to capture details about discovered devices."""
+
+    def __init__(
+        self,
+        mac: str,
+        host: str,
+        host_type: str,
+        insert_type: str,
+        friendly_name: str = "Swidget Discovered Device",
+    ):
         self.mac = mac
         self.host = host
         self.friendly_name = friendly_name
+        self.host_type = host_type
+        self.insert_type = insert_type
 
 
 class SwidgetProtocol(ssdp.SimpleServiceDiscoveryProtocol):
     """Protocol to handle responses and requests."""
+
     def response_received(self, response: ssdp.SSDPResponse, addr: tuple):
-        "Handle an incoming response."
+        """Handle an incoming response."""
         headers = {h[0]: h[1] for h in response.headers}
         mac_address = headers["USN"].split("-")[-1]
         ip_address = urlparse(headers["LOCATION"]).hostname
@@ -37,11 +51,20 @@ class SwidgetProtocol(ssdp.SimpleServiceDiscoveryProtocol):
             device_type = headers["SERVER"].split(" ")[1].split("+")[0]
             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)
-            _LOGGER.debug(f"Swidget device '{friendly_name}' at {ip_address}. {device_type}/{insert_type}")
+            devices[mac_address] = SwidgetDiscoveredDevice(
+                mac=mac_address,
+                host=ip_address,
+                friendly_name=friendly_name,
+                host_type=device_type,
+                insert_type=insert_type,
+            )
+            _LOGGER.debug(
+                f"Swidget device '{friendly_name}' at {ip_address}. {device_type}/{insert_type}"
+            )
 
 
 async def discover_devices(timeout=RESPONSE_SEC):
+    """Discover devices via SSDP."""
     global devices
     loop = asyncio.get_event_loop()
     devices = dict()
@@ -64,7 +87,9 @@ async def discover_devices(timeout=RESPONSE_SEC):
     return devices
 
 
-async def discover_single(host: str, token_name: str, password: str, use_https: bool, use_websockets: bool) -> Any:
+async def discover_single(
+    host: str, token_name: str, password: str, use_https: bool, use_websockets: bool
+) -> Any:
     """Discover a single device by the given IP address.
 
     :param host: Hostname of device to query
@@ -72,7 +97,9 @@ async def discover_single(host: str, token_name: str, password: str, use_https:
     :return: Object for querying/controlling found device.
     """
     _LOGGER.debug(f"Checking for device at {host}")
-    swidget_device = SwidgetDevice(host, token_name, password, use_https, use_websockets=False)
+    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
@@ -95,7 +122,7 @@ def _get_device_class(device_type: DeviceType) -> Type[SwidgetDevice]:
         return SwidgetSwitch
     elif device_type == DeviceType.Dimmer:
         return SwidgetDimmer
-    elif device_type == DeviceType.TimerSwitch: # This is the timer switch
+    elif device_type == DeviceType.TimerSwitch:  # This is the timer switch
         return SwidgetTimerSwitch
     elif device_type == DeviceType.RelaySwitch:
         return SwidgetSwitch

{python_swidget-1.2.2 → python_swidget-1.2.3}/swidget/provision.py

@@ -1,42 +1,48 @@
-from enum import Enum
+"""Provision the Swidget device in local-only mode."""
 import time
+from enum import Enum
 
-import requests
+import requests  # type: ignore
 import urllib3
 
 urllib3.disable_warnings()
 
 
 class DeviceConnectionResult(str, Enum):
-    NoStarted = "NotInitiated",
-    InProgress ="AttemptingConnect",
-    Success = "Success",
-    AuthenticationFailure = "AuthFail",
-    SSIDNotFound = "SSIDNotFound",
-    NoIp = "NoIpReceived",
+    """Enum class for provisioning results."""
+
+    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}
+    """Send the credentials to the Swidget device."""
+    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.")
+            print("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")
+                print("Provision Success")
                 return True, initial_provision.json()["secretKey"]
             else:
-                print(f"Provision Failed: {initial_provision.json()}")
+                print("Provision Failed: {initial_provision.json()}")
                 return False, None
         except Exception as e:
             print("Error", e)
@@ -45,61 +51,73 @@ def send_credentials(device_name, ssid, network_password, secret_key):
 
 
 def verify_connect_result(key):
-    headers = {'x-secret-key': key}
-    connect_success = False
+    """Function to query the device and verify if the device is successfully provisioned."""
+    headers = {"x-secret-key": key}
     connect_verification_attempts = 0
-    while not connect_success:
+    while connect_verification_attempts < 5:
         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
+                if connect_status == "Success":
+                    return (
+                        True,
+                        verify_connection.json()["ip"],
+                        verify_connection.json()["mac"],
+                        None,
+                    )
+                elif connect_status == "InProgress":
+                    time.sleep(5)
+                    connect_verification_attempts += 1
+                    continue
                 else:
                     return False, None, None, connect_status
             else:
                 print(f"Verification request failure: {verify_connection.json()}")
+                time.sleep(5)
+        except Exception as e:
+            print(e)
             time.sleep(5)
-        except:
-            time.sleep(5)
-            connect_verification_attempts += 1
+        connect_verification_attempts += 1
+    return False, None, None, "Internal server error"
 
 
 def provision_wifi(device_name, ssid, network_password, secret_key):
+    """Main function to provision credentials to the Swidget device."""
     print(f"Device_name: {device_name}")
     print(f"SSID: {ssid}")
-    print(f"Network Password: <redacted>")
-    print(f"Swidget Secret Key: <redacted>")
+    print("Network Password: <redacted>")
+    print("Swidget Secret Key: <redacted>")
 
-    send_success, key = send_credentials(device_name, ssid, network_password, secret_key)
+    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)
+    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}
+    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)
+    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
+    # alternatively, sleep for some time
     print("Device has been configured, switch your wifi network off `Swidget-` now")
     time.sleep(30)
 
@@ -109,8 +127,10 @@ def provision_wifi(device_name, ssid, network_password, secret_key):
         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")
+            print(
+                f"Verifying device name has been set: {verify_name}. Provisioning complete"
+            )
             return True
-        except:
+        except Exception:
             print("Connect to provided network")
-        time.sleep(5)
+        time.sleep(5)