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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-swidget
-Version: 1.0.1
+Version: 1.0.2
 Summary: Python API for Swidget smart devices
 Home-page: https://github.com/swidget/python-swidget
 License: GPL-3.0-or-later
@@ -21,10 +21,12 @@ Requires-Dist: importlib-metadata
 Requires-Dist: m2r (>=0,<1) ; extra == "docs"
 Requires-Dist: mistune (<2.0.0) ; extra == "docs"
 Requires-Dist: pydantic (>=1,<2)
+Requires-Dist: requests (==2.31.0)
 Requires-Dist: sphinx (>=4,<5) ; extra == "docs"
 Requires-Dist: sphinx_rtd_theme (>=0,<1) ; extra == "docs"
 Requires-Dist: sphinxcontrib-programoutput (>=0,<1) ; extra == "docs"
 Requires-Dist: ssdp (==1.1.1)
+Requires-Dist: types-requests (==2.31.0.20240406)
 Project-URL: Repository, https://github.com/swidget/python-swidget
 Description-Content-Type: text/markdown
 

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-swidget"
-version = "1.0.1"
+version = "1.0.2"
 description = "Python API for Swidget smart devices"
 license = "GPL-3.0-or-later"
 authors = ["Swidget"]
@@ -22,6 +22,8 @@ importlib-metadata = "*"
 asyncclick = ">=8"
 pydantic = "^1"
 ssdp = "1.1.1"
+requests = "2.31.0"
+types-requests = "2.31.0.20240406"
 
 # required only for docs
 sphinx = { version = "^4", optional = true }

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

@@ -1,8 +1,8 @@
 """python-swidget cli tool."""
 import logging
 import sys
+from typing import Any, cast
 from pprint import pformat as pf
-from typing import cast
 
 import asyncclick as click
 from contextlib import asynccontextmanager
@@ -25,8 +25,6 @@ TYPE_TO_CLASS = {
     "pana_switch": SwidgetTimerSwitch
 }
 
-click.anyio_backend = "asyncio"
-
 
 pass_dev = click.make_pass_decorator(SwidgetDevice)
 
@@ -72,7 +70,7 @@ async def cli(ctx, host, password, debug, http_only, type):
     if ctx.invoked_subcommand == "discover" or ctx.invoked_subcommand == "wifi":
         return
     if host is None:
-        click.echo("No host name given, trying discovery..")
+        click.echo("No hostname or IP given, trying discovery..")
         await ctx.invoke(discover)
         return
     if type is not None:
@@ -193,31 +191,25 @@ async def state(dev: SwidgetDevice):
 @click.argument("command")
 async def raw_command(dev: SwidgetDevice, assembly, component, function, command):
     """Run a raw command on the device."""
-    import ast
-
-    if parameters is not None:
-        parameters = ast.literal_eval(parameters)
-
-    res = await dev.send_command(assembly, component, function, command)
-
-    click.echo(res)
-    return res
+    await dev.send_command(assembly, component, function, command)
+    click.echo("Command sent")
 
 
 @cli.command()
 @click.argument("brightness", type=click.IntRange(0, 100), default=None, required=False)
 @pass_dev
-async def brightness(dev: SwidgetDimmer, brightness: int):
+async def brightness(dev: SwidgetDevice, brightness: Any=None):
+    dimmer_dev = cast(SwidgetDimmer, dev)
     """Get or set brightness."""
-    if not dev.is_dimmer:
+    if not dimmer_dev.is_dimmer:
         click.echo("This device does not support brightness.")
         return
 
     if brightness is None:
-        click.echo(f"Brightness: {dev.brightness}")
+        click.echo(f"Brightness: {dimmer_dev.brightness}")
     else:
         click.echo(f"Setting brightness to {brightness}")
-        return await dev.set_brightness(brightness)
+        return await dimmer_dev.set_brightness(brightness)
 
 
 @cli.command()

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

@@ -1,11 +1,10 @@
 import asyncio
-import json
 import logging
 import socket
-from typing import Awaitable, Callable, Dict, Optional, Type, cast
+from typing import Any, Type
 from urllib.parse import urlparse
 
-import ssdp
+import ssdp  # type: ignore
 
 from swidget.swidgetdevice import DeviceType, SwidgetDevice
 from .swidgetdimmer import SwidgetDimmer
@@ -39,7 +38,7 @@ 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)
-            _LOGGER.debug(f"Swidget device '{friendly_name}' at {ip_address}")
+            _LOGGER.debug(f"Swidget device '{friendly_name}' at {ip_address}. {device_type}/{insert_type}")
 
 
 async def discover_devices(timeout=RESPONSE_SEC):
@@ -65,7 +64,7 @@ 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) -> SwidgetDevice:
+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
@@ -88,16 +87,16 @@ async def discover_single(host: str, token_name: str, password: str, use_https:
     return dev
 
 
-def _get_device_class(device_type: str) -> Type[SwidgetDevice]:
+def _get_device_class(device_type: DeviceType) -> Type[SwidgetDevice]:
     """Find SmartDevice subclass for device described by passed data."""
-    if device_type == "outlet":
+    if device_type == DeviceType.Outlet:
         return SwidgetOutlet
-    elif device_type == "switch":
+    elif device_type == DeviceType.Switch:
         return SwidgetSwitch
-    elif device_type == "dimmer":
+    elif device_type == DeviceType.Dimmer:
         return SwidgetDimmer
-    elif device_type == "pana_switch": # This is the timer switch
+    elif device_type == DeviceType.TimerSwitch: # This is the timer switch
         return SwidgetTimerSwitch
-    elif device_type == "relay_switch":
+    elif device_type == DeviceType.RelaySwitch:
         return SwidgetSwitch
     raise SwidgetException("Unknown device type: %s" % device_type)

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

@@ -5,7 +5,7 @@ import time
 from aiohttp import ClientSession, TCPConnector
 import asyncio
 from enum import Enum
-from typing import Dict, List, Set
+from typing import Any, Dict, List
 
 from .exceptions import SwidgetException
 from .websocket import SwidgetWebsocket
@@ -24,22 +24,21 @@ class DeviceType(Enum):
 
 
 class SwidgetDevice:
-    def __init__(self, host, token_name, secret_key, use_https=True, use_websockets=True):
+    def __init__(self, host, token_name, secret_key, use_https=True, use_websockets=True) -> None:
         self.token_name = token_name
         self.ip_address = host
-
         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"
-        self.assemblies = {}
+        self.assemblies: Dict[Any, Any] = dict()
         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
+        self._last_update: int = 0
         if self.use_websockets:
             self._websocket = SwidgetWebsocket(
                 host=self.ip_address,
@@ -48,18 +47,18 @@ class SwidgetDevice:
                 callback=self.message_callback,
                 session=self._session)
 
-    def get_websocket(self):
+    def get_websocket(self) -> SwidgetWebsocket | None:
         if self.use_websockets:
             return self._websocket
         return None
 
-    def set_countdown_timer(self, minutes):
+    def set_countdown_timer(self, minutes) -> Any:
         raise NotImplementedError()
 
-    async def connect(self):
+    async def connect(self) -> None:
         await self._websocket.connect()
 
-    async def start(self):
+    async def start(self) -> None:
         """Start the websocket."""
         _LOGGER.debug("SwidgetDevice.start()")
         if self.use_websockets:
@@ -68,17 +67,17 @@ class SwidgetDevice:
         _LOGGER.debug("Calling self.update() ")
         await self.update()
 
-    async def stop(self):
+    async def stop(self) -> None:
         """Stop the websocket."""
         _LOGGER.debug("SwidgetDevice.stop()")
         if hasattr(self, '_websocket'):
             await self._websocket.close()
         await self._session.close()
 
-    async def close(self):
+    async def close(self) -> None:
         await self.stop()
 
-    async def message_callback(self, message):
+    async def message_callback(self, message) -> None:
         """Entrypoint for a websocket callback"""
         _LOGGER.debug("SwidgetDevice.message_callback() called")
         if message["request_id"] == "summary":
@@ -90,7 +89,7 @@ class SwidgetDevice:
         else:
             _LOGGER.error(f"Unknown message type from websocket. Type given was: {message["request_id"]}")
 
-    async def get_summary(self):
+    async def get_summary(self) -> None:
         """Get a summary of the device over HTTP"""
         _LOGGER.debug("SwidgetDevice.get_summary() called")
         if self.use_websockets:
@@ -104,7 +103,7 @@ class SwidgetDevice:
                 summary = await response.json()
             await self.process_summary(summary)
 
-    async def process_summary(self, summary):
+    async def process_summary(self, summary) -> None:
         """ Process the data around the summary of the device"""
         _LOGGER.debug("SwidgetDevice.process_summary() called")
         _LOGGER.debug(f"Summary to process: {summary}")
@@ -115,12 +114,12 @@ class SwidgetDevice:
             "host": SwidgetAssembly(summary["host"]),
             "insert": SwidgetAssembly(summary["insert"]),
         }
-        self.device_type = self.assemblies['host'].type
+        self.device_type = DeviceType(self.assemblies['host'].type)
         self.insert_type = self.assemblies['insert'].type
         self.id = self.assemblies['host'].id
         self._last_update = int(time.time())
 
-    async def get_friendly_name(self):
+    async def get_friendly_name(self) -> None:
         _LOGGER.debug("SwidgetDevice.get_friendly_name() called")
         try:
             async with self._session.get(
@@ -131,12 +130,12 @@ class SwidgetDevice:
             name = {"name": f"Swidget {self.device_type} w/{self.insert_type} insert"}
         await self.process_friendly_name(name['name'])
 
-    async def process_friendly_name(self, name):
+    async def process_friendly_name(self, name) -> None:
         _LOGGER.debug("SwidgetDevice.process_friendly_name() called")
         self._friendly_name = name
         self._last_update = int(time.time())
 
-    async def get_state(self):
+    async def get_state(self) -> None:
         """ Get the state of the device over HTTP"""
         _LOGGER.debug("SwidgetDevice.get_state() called")
         if self.use_websockets:
@@ -150,7 +149,7 @@ class SwidgetDevice:
                 state = await response.json()
             await self.process_state(state)
 
-    async def process_state(self, state):
+    async def process_state(self, state) -> None:
         """ 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")
@@ -167,9 +166,9 @@ class SwidgetDevice:
                     pass
         self._last_update = int(time.time())
 
-    async def update(self):
+    async def update(self) -> None:
         _LOGGER.debug("SwidgetDevice.update() called")
-        if self._last_update is None:
+        if self._last_update == 0:
             _LOGGER.debug("Performing the initial update to obtain sysinfo")
             await self.get_summary()
             await self.get_state()
@@ -182,25 +181,25 @@ class SwidgetDevice:
             await self.get_summary()
             await self.get_state()
 
-    async def send_config(self, payload: dict):
+    async def send_config(self, payload: dict) -> None:
         _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
-    ):
+    ) -> None:
         _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",
+            command_data = json.dumps({"type": "command",
                                "request_id": "command",
                                "payload": data
                                })
-            await self._websocket.send_str(data)
+            await self._websocket.send_str(command_data)
         else:
             _LOGGER.debug("NOT in websocket mode, sending command over HTTP")
             async with self._session.post(
@@ -214,7 +213,7 @@ class SwidgetDevice:
             function_value = state[assembly]["components"][component][function]
             self.assemblies[assembly].components[component].functions[function] = function_value  # fmt: skip
 
-    async def ping(self):
+    async def ping(self) -> int | SwidgetException:
         """Ping the device to ensure it's devices
 
         :raises SwidgetException: Raise the exception if there we are unable to connect to the Swidget device
@@ -229,7 +228,7 @@ class SwidgetDevice:
         except:
             raise SwidgetException
 
-    async def blink(self):
+    async def blink(self) -> Any:
         """Make the device LED blink
 
         :raises SwidgetException: Raise the exception if there we are unable to connect to the Swidget device
@@ -244,7 +243,7 @@ class SwidgetDevice:
         except:
             raise SwidgetException
 
-    async def enable_debug_server(self):
+    async def enable_debug_server(self) -> Any:
         """Enable the Swidget local debug server
 
         :raises SwidgetException: Raise the exception if there we are unable to connect to the Swidget device
@@ -259,7 +258,7 @@ class SwidgetDevice:
         except:
             raise SwidgetException
 
-    async def factory_reset(self):
+    async def factory_reset(self) -> Any:
         """Factory reset the Swidget device
 
         :raises SwidgetException: Raise the exception if there we are unable to connect to the Swidget device
@@ -274,7 +273,7 @@ class SwidgetDevice:
         except:
             raise SwidgetException
 
-    async def check_for_updates(self):
+    async def check_for_updates(self) -> Any:
         """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
@@ -289,7 +288,7 @@ class SwidgetDevice:
         except:
             raise SwidgetException
 
-    async def update_version(self, version):
+    async def update_version(self, version) -> Any:
         """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
@@ -303,7 +302,7 @@ class SwidgetDevice:
                 ssl=False,
                 data=json.dumps(data)
             ) as response:
-                return await response
+                return await response.json()
         except:
             raise SwidgetException
 
@@ -326,7 +325,7 @@ class SwidgetDevice:
             "rssi": self.rssi
         }
 
-    async def get_child_consumption(self, plug_id=0):
+    async def get_child_consumption(self, plug_id=0) -> Any:
         """Get the power consumption of a plug in watts."""
         if plug_id == "all":
             return_dict = {}
@@ -338,7 +337,7 @@ class SwidgetDevice:
             return return_dict
         return self.assemblies['host'].components[str(plug_id)].functions['power']['current']
 
-    async def total_consumption(self):
+    async def total_consumption(self) -> float:
         """Get the total power consumption in watts."""
         total_consumption = 0
         for id, properties in self.assemblies['host'].components.items():
@@ -346,7 +345,7 @@ class SwidgetDevice:
         return total_consumption
 
     @property
-    async def realtime_values(self):
+    async def realtime_values(self) -> Dict:
         """Get a dict of realtime value attributes from the insert and host
 
         :return: A dictionary of insert sensor values and power consumption values
@@ -367,7 +366,7 @@ class SwidgetDevice:
         try:
             return list(self.assemblies['host'].components['0'].functions.keys())
         except KeyError:
-            return set()
+            return list()
 
     @property
     def insert_features(self) -> List[str]:
@@ -375,9 +374,9 @@ class SwidgetDevice:
         try:
             return list(self.assemblies['insert'].components.keys())
         except KeyError:
-            return set()
+            return list()
 
-    def get_function_values(self, function: str):
+    def get_function_values(self, function: str) -> Dict:
         """Return the values of an insert function."""
         return_values = dict()
         for function, data in self.assemblies['insert'].components[function].functions.items():
@@ -389,7 +388,7 @@ class SwidgetDevice:
                 return_values[function] = data['now']
         return return_values
 
-    def get_sensor_value(self, function, sensor):
+    def get_sensor_value(self, function, sensor) -> float | str:
         """Return the value of a sensor given a function and sensor"""
         if sensor == "occupied":
             return self.assemblies['insert'].components[function].functions['occupied']['state']
@@ -399,22 +398,22 @@ class SwidgetDevice:
     @property
     def is_outlet(self) -> bool:
         """Return True if the device is an outlet."""
-        return self.device_type == "outlet"
+        return self.device_type == DeviceType.Outlet
 
     @property
     def is_switch(self) -> bool:
         """Return True if the device is a switch"""
-        return self.device_type == "switch" or self.device_type == "pana_switch" or self.device_type == "relay_switch"
+        return self.device_type == DeviceType.Switch or self.device_type == DeviceType.TimerSwitch or self.device_type == DeviceType.RelaySwitch
 
     @property
     def is_pana_switch(self) -> bool:
         """Return True if the device is a pana_switch"""
-        return self.device_type == "pana_switch"
+        return self.device_type == DeviceType.TimerSwitch
 
     @property
     def is_dimmer(self) -> bool:
         """Return True if the device is a dimmer"""
-        return self.device_type == "dimmer"
+        return self.device_type == DeviceType.Dimmer
 
     @property
     def is_dimmable(self) -> bool:
@@ -434,27 +433,27 @@ class SwidgetDevice:
             return True
         return False
 
-    async def turn_on(self):
+    async def turn_on(self) -> None:
         """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):
+    async def turn_off(self) -> None:
         """Turn the device off."""
         _LOGGER.debug("SwidgetDevice.turn_off() called")
         await self.send_command(
             assembly="host", component="0", function="toggle", command={"state": "off"}
         )
 
-    async def turn_on_usb_insert(self):
+    async def turn_on_usb_insert(self) -> None:
         """Turn the USB insert on."""
         await self.send_command(
             assembly="insert", component="usb", function="toggle", command={"state": "on"}
         )
 
-    async def turn_off_usb_insert(self):
+    async def turn_off_usb_insert(self) -> None:
         """Turn the USB insert off."""
         await self.send_command(
             assembly="insert", component="usb", function="toggle", command={"state": "off"}
@@ -468,8 +467,8 @@ class SwidgetDevice:
             return True
         return False
 
-    def __repr__(self):
-        if self._last_update is None:
+    def __repr__(self) -> str:
+        if self._last_update == 0:
             return f"<{self.device_type} at {self.ip_address} - update() needed>"
         return f"<{self.device_type} model {self.model} at {self.ip_address}>"
 

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

@@ -28,14 +28,14 @@ class SwidgetDimmer(SwidgetDevice):
         except KeyError:
             return self.assemblies['host'].components["0"].functions["level"]["default"]
 
-    async def set_brightness(self, brightness):
+    async def set_brightness(self, brightness) -> None:
         """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):
+    async def set_default_brightness(self, brightness) -> None:
         _LOGGER.debug("SwidgetDimmer.set_default_brightness() called")
         await self.send_command(
             assembly="host", component="0", function="level", command={"default": brightness}

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

@@ -8,8 +8,4 @@ class SwidgetSwitch(SwidgetDevice):
 
     def __init__(self, host,  token_name: str, secret_key: str, use_https: bool, use_websockets: bool) -> None:
         super().__init__(host=host, token_name=token_name, secret_key=secret_key, use_https=use_https, use_websockets=use_websockets)
-        self._device_type = DeviceType.Switch
-
-    async def current_consumption(self) -> float:
-        """Get the current power consumption in watts."""
-        return sum([await plug.current_consumption() for plug in self.children])
+        self._device_type = DeviceType.Switch

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

@@ -1,4 +1,6 @@
 import logging
+from typing import Any
+
 from swidget.swidgetdevice import (
     DeviceType,
 )
@@ -13,7 +15,7 @@ class SwidgetTimerSwitch(SwidgetSwitch):
         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):
+    async def set_countdown_timer(self, minutes) -> Any:
         """Set the countdown timer."""
         _LOGGER.debug("SwidgetTimerSwitch.set_brightness() called")
         await self.send_command(

{python_swidget-1.0.1 → python_swidget-1.0.2}/swidget/websocket.py

@@ -33,7 +33,7 @@ class SwidgetWebsocket:
         session=None,
         use_security=True,
     ):
-
+        self.host = host
         self.session = session or aiohttp.ClientSession()
         self.use_security = use_security
         self.uri = self.get_uri(host, token_name, secret_key)
@@ -52,7 +52,7 @@ class SwidgetWebsocket:
     @property
     def websocket(self) -> ClientWebSocketResponse | None:
         """Return the web socket."""
-        return self._ws
+        return self._client
 
     def get_uri(self, host, token_name, secret_key):
         """Generate the websocket URI"""
@@ -75,16 +75,18 @@ class SwidgetWebsocket:
         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)
+        except aiohttp.WSServerHandshakeError as handshake_error:
+            _LOGGER.error(f"Error occurred during websocket handshake: {handshake_error}")
+            raise
+        except aiohttp.ClientConnectionError as connection_error:
+            _LOGGER.error(f"Error connecting to the websocket server: {connection_error}")
+            raise
+        except socket.gaierror as gai_error:
+            _LOGGER.error(f"Error resolving host: {gai_error}")
+            raise
+        except Exception as e:
+            _LOGGER.error(f"An unexpected error occurred: {e}")
+            raise
         self._receiver_task = asyncio.ensure_future(self.listen())
 
     async def close(self) -> None: