python-swidget 1.3.2__tar.gz → 1.4.0__tar.gz

python_swidget-1.4.0/PKG-INFO

@@ -0,0 +1,270 @@
+Metadata-Version: 2.4
+Name: python-swidget
+Version: 1.4.0
+Summary: Python API for Swidget smart devices
+License: GPL-3.0-or-later
+Author: Swidget
+Requires-Python: >=3.8,<4.0
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Programming Language :: Python :: 3
+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
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Provides-Extra: docs
+Requires-Dist: aiohttp (>=3.8.1)
+Requires-Dist: anyio
+Requires-Dist: asyncclick (>=8)
+Requires-Dist: importlib-metadata
+Requires-Dist: m2r (>=0,<1) ; extra == "docs"
+Requires-Dist: mistune (<2.0.0) ; extra == "docs"
+Requires-Dist: pydantic (>=2,<3)
+Requires-Dist: requests (==2.32.5)
+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.32.0,<3.0.0)
+Requires-Dist: urllib3 (==2.5.0)
+Project-URL: Repository, https://github.com/swidget/python-swidget
+Description-Content-Type: text/markdown
+
+python-swidget
+==============
+
+![CI](https://github.com/swidget/python-swidget/actions/workflows/ci.yml/badge.svg)
+![PyPI](https://img.shields.io/pypi/v/python-swidget)
+![License](https://img.shields.io/pypi/l/python-swidget)
+
+Python SDK for Swidget smart devices. It supports local HTTP control and websockets for realtime updates, along with SSDP discovery, Wi-Fi provisioning helpers, and a CLI tool (`swidget`).
+
+Table of contents
+-----------------
+- Installation
+- Quickstart
+- Device types and helpers
+- HTTP vs websocket modes
+- Discovery
+- Provisioning (AP mode)
+- CLI usage
+- Development (tests, lint, hooks)
+
+Installation
+------------
+Using Poetry (preferred):
+```
+poetry install --with dev
+```
+
+Using pip:
+```
+pip install python-swidget
+```
+
+Quickstart
+----------
+```python
+from swidget import SwidgetDimmer
+
+dev = SwidgetDimmer(
+    host="192.168.1.50",
+    token_name="x-secret-key",
+    secret_key="password",
+    use_https=True,
+    use_websockets=False,  # set True for realtime updates
+)
+
+# HTTP-only mode
+await dev.update()
+await dev.turn_on()
+await dev.turn_off()
+await dev.close()
+```
+
+Websocket mode (realtime)
+```python
+dev = SwidgetDimmer(
+    host="192.168.1.50",
+    token_name="x-secret-key",
+    secret_key="password",
+    use_https=True,
+    use_websockets=True,
+)
+await dev.start()   # opens websocket and updates state
+await dev.turn_on()
+await dev.close()
+```
+
+Device types and helpers
+------------------------
+- `SwidgetDevice` – base class (shared HTTP/websocket helpers)
+- `SwidgetDimmer` – brightness control (`brightness`, `set_brightness`)
+- `SwidgetOutlet` – outlet control (`turn_on`, `turn_off`, power readings)
+- `SwidgetSwitch` – generic switch control (`turn_on`, `turn_off`)
+- `SwidgetTimerSwitch` – timer-capable switch (`set_countdown_timer`)
+
+Common properties:
+- `device_type`, `insert_type`, `friendly_name`, `hw_info`
+- `realtime_values`: convenience dict of sensor/power values
+
+Common actions:
+- `turn_on()`, `turn_off()`, `blink()`, `ping()`
+- `update()` to refresh summary/state/config
+- `send_command(assembly, component, function, command_dict)` for raw control
+
+HTTP vs websocket modes
+-----------------------
+- HTTP-only: set `use_websockets=False`. All operations go over REST (`/api/v1/...`).
+- Websocket mode: set `use_websockets=True`. Summary/state updates and commands use the socket when connected; HTTP is used as fallback where applicable.
+- TLS: `use_https=True` disables certificate verification by default; pass `verify_ssl=True` when constructing `SwidgetDevice` if you have valid certs.
+
+Discovery
+---------
+Discover devices via SSDP:
+```python
+from swidget import discover_devices
+devices = await discover_devices(timeout=5)
+for mac, dev in devices.items():
+    print(dev.host, dev.friendly_name, dev.host_type, dev.insert_type)
+```
+
+Discover a single device when you know the IP:
+```python
+from swidget import discover_single
+dev = await discover_single(
+    host="192.168.1.50",
+    token_name="x-secret-key",
+    password="device_password",
+    use_https=True,
+    use_websockets=False,
+)
+await dev.update()
+```
+
+Provisioning (AP mode)
+----------------------
+Provision a device while connected to its AP (`Swidget-...` SSID):
+```python
+from swidget import provision_wifi
+provision_wifi(
+    device_name="My Swidget",
+    ssid="HomeWiFi",
+    network_password="wifi-pass",
+    secret_key="factory-secret",
+)
+```
+Notes:
+- Provisioning disables TLS verification; run only on the device’s AP network.
+- The helper waits for connection success and triggers setup completion.
+
+CLI usage
+---------
+Install the console entrypoint via Poetry/pip and run:
+```
+swidget --host 192.168.1.50 --password device_password --type dimmer state
+swidget --host 192.168.1.50 --password device_password on
+swidget --host 192.168.1.50 --password device_password brightness 80
+swidget discover
+```
+Key options:
+- `--http_only` (flag) to force HTTP-only (no websockets)
+- `--type` to skip discovery when you know the device type
+- `wifi join` to provision via AP (prompts for SSID/password)
+
+Development
+-----------
+Run tests and lint (hook runs both):
+```
+pytest
+black --check .
+```
+
+If you install via plain pip and want the dev toolchain (tests, typing, docs, formatting):
+```
+pip install pytest pytest-asyncio aioresponses mypy black sphinx sphinx-rtd-theme sphinx-autobuild
+```
+
+Enable git hook (optional):
+```
+git config core.hooksPath githooks
+```
+
+Code structure:
+- `swidget/` core library: device models, discovery, provisioning, websocket client, CLI
+- `tests/` unit tests (network mocked)
+- `devtools/synthetic_test.py` optional integration script for real devices (kept separate from unit tests)
+- `examples/` runnable samples (dimmer HTTP, outlet power, timer switch, snapshot)
+
+Additional examples
+-------------------
+
+Outlet (power reading + toggle)
+```
+from swidget import SwidgetOutlet
+
+dev = SwidgetOutlet(
+    host="192.168.1.60",
+    token_name="x-secret-key",
+    secret_key="password",
+    use_https=True,
+    use_websockets=False,
+)
+await dev.update()
+print("Host features:", dev.host_features)
+print("Realtime values:", dev.realtime_values)
+await dev.turn_on()
+await dev.turn_off()
+await dev.close()
+```
+
+Timer switch
+```
+from swidget import SwidgetTimerSwitch
+
+dev = SwidgetTimerSwitch(
+    host="192.168.1.61",
+    token_name="x-secret-key",
+    secret_key="password",
+    use_https=True,
+    use_websockets=False,
+)
+await dev.set_countdown_timer(20)  # minutes
+await dev.close()
+```
+
+Snapshots (video-capable insert)
+```
+from swidget import SwidgetDevice
+
+dev = SwidgetDevice(
+    host="192.168.1.62",
+    token_name="x-secret-key",
+    secret_key="password",
+    use_https=True,
+    use_websockets=False,
+)
+await dev.update()
+img = await dev.get_snapshot_bytes(width=640, height=360)
+with open("snapshot.jpg", "wb") as f:
+    f.write(img)
+await dev.close()
+```
+
+Type checking
+-------------
+Run mypy in strict mode:
+```
+poetry run mypy --strict swidget
+```
+
+Docs build
+----------
+Generate HTML docs with Sphinx:
+```
+cd docs
+poetry run sphinx-build -b html . _build
+```
+

python_swidget-1.4.0/README.md

@@ -0,0 +1,235 @@
+python-swidget
+==============
+
+![CI](https://github.com/swidget/python-swidget/actions/workflows/ci.yml/badge.svg)
+![PyPI](https://img.shields.io/pypi/v/python-swidget)
+![License](https://img.shields.io/pypi/l/python-swidget)
+
+Python SDK for Swidget smart devices. It supports local HTTP control and websockets for realtime updates, along with SSDP discovery, Wi-Fi provisioning helpers, and a CLI tool (`swidget`).
+
+Table of contents
+-----------------
+- Installation
+- Quickstart
+- Device types and helpers
+- HTTP vs websocket modes
+- Discovery
+- Provisioning (AP mode)
+- CLI usage
+- Development (tests, lint, hooks)
+
+Installation
+------------
+Using Poetry (preferred):
+```
+poetry install --with dev
+```
+
+Using pip:
+```
+pip install python-swidget
+```
+
+Quickstart
+----------
+```python
+from swidget import SwidgetDimmer
+
+dev = SwidgetDimmer(
+    host="192.168.1.50",
+    token_name="x-secret-key",
+    secret_key="password",
+    use_https=True,
+    use_websockets=False,  # set True for realtime updates
+)
+
+# HTTP-only mode
+await dev.update()
+await dev.turn_on()
+await dev.turn_off()
+await dev.close()
+```
+
+Websocket mode (realtime)
+```python
+dev = SwidgetDimmer(
+    host="192.168.1.50",
+    token_name="x-secret-key",
+    secret_key="password",
+    use_https=True,
+    use_websockets=True,
+)
+await dev.start()   # opens websocket and updates state
+await dev.turn_on()
+await dev.close()
+```
+
+Device types and helpers
+------------------------
+- `SwidgetDevice` – base class (shared HTTP/websocket helpers)
+- `SwidgetDimmer` – brightness control (`brightness`, `set_brightness`)
+- `SwidgetOutlet` – outlet control (`turn_on`, `turn_off`, power readings)
+- `SwidgetSwitch` – generic switch control (`turn_on`, `turn_off`)
+- `SwidgetTimerSwitch` – timer-capable switch (`set_countdown_timer`)
+
+Common properties:
+- `device_type`, `insert_type`, `friendly_name`, `hw_info`
+- `realtime_values`: convenience dict of sensor/power values
+
+Common actions:
+- `turn_on()`, `turn_off()`, `blink()`, `ping()`
+- `update()` to refresh summary/state/config
+- `send_command(assembly, component, function, command_dict)` for raw control
+
+HTTP vs websocket modes
+-----------------------
+- HTTP-only: set `use_websockets=False`. All operations go over REST (`/api/v1/...`).
+- Websocket mode: set `use_websockets=True`. Summary/state updates and commands use the socket when connected; HTTP is used as fallback where applicable.
+- TLS: `use_https=True` disables certificate verification by default; pass `verify_ssl=True` when constructing `SwidgetDevice` if you have valid certs.
+
+Discovery
+---------
+Discover devices via SSDP:
+```python
+from swidget import discover_devices
+devices = await discover_devices(timeout=5)
+for mac, dev in devices.items():
+    print(dev.host, dev.friendly_name, dev.host_type, dev.insert_type)
+```
+
+Discover a single device when you know the IP:
+```python
+from swidget import discover_single
+dev = await discover_single(
+    host="192.168.1.50",
+    token_name="x-secret-key",
+    password="device_password",
+    use_https=True,
+    use_websockets=False,
+)
+await dev.update()
+```
+
+Provisioning (AP mode)
+----------------------
+Provision a device while connected to its AP (`Swidget-...` SSID):
+```python
+from swidget import provision_wifi
+provision_wifi(
+    device_name="My Swidget",
+    ssid="HomeWiFi",
+    network_password="wifi-pass",
+    secret_key="factory-secret",
+)
+```
+Notes:
+- Provisioning disables TLS verification; run only on the device’s AP network.
+- The helper waits for connection success and triggers setup completion.
+
+CLI usage
+---------
+Install the console entrypoint via Poetry/pip and run:
+```
+swidget --host 192.168.1.50 --password device_password --type dimmer state
+swidget --host 192.168.1.50 --password device_password on
+swidget --host 192.168.1.50 --password device_password brightness 80
+swidget discover
+```
+Key options:
+- `--http_only` (flag) to force HTTP-only (no websockets)
+- `--type` to skip discovery when you know the device type
+- `wifi join` to provision via AP (prompts for SSID/password)
+
+Development
+-----------
+Run tests and lint (hook runs both):
+```
+pytest
+black --check .
+```
+
+If you install via plain pip and want the dev toolchain (tests, typing, docs, formatting):
+```
+pip install pytest pytest-asyncio aioresponses mypy black sphinx sphinx-rtd-theme sphinx-autobuild
+```
+
+Enable git hook (optional):
+```
+git config core.hooksPath githooks
+```
+
+Code structure:
+- `swidget/` core library: device models, discovery, provisioning, websocket client, CLI
+- `tests/` unit tests (network mocked)
+- `devtools/synthetic_test.py` optional integration script for real devices (kept separate from unit tests)
+- `examples/` runnable samples (dimmer HTTP, outlet power, timer switch, snapshot)
+
+Additional examples
+-------------------
+
+Outlet (power reading + toggle)
+```
+from swidget import SwidgetOutlet
+
+dev = SwidgetOutlet(
+    host="192.168.1.60",
+    token_name="x-secret-key",
+    secret_key="password",
+    use_https=True,
+    use_websockets=False,
+)
+await dev.update()
+print("Host features:", dev.host_features)
+print("Realtime values:", dev.realtime_values)
+await dev.turn_on()
+await dev.turn_off()
+await dev.close()
+```
+
+Timer switch
+```
+from swidget import SwidgetTimerSwitch
+
+dev = SwidgetTimerSwitch(
+    host="192.168.1.61",
+    token_name="x-secret-key",
+    secret_key="password",
+    use_https=True,
+    use_websockets=False,
+)
+await dev.set_countdown_timer(20)  # minutes
+await dev.close()
+```
+
+Snapshots (video-capable insert)
+```
+from swidget import SwidgetDevice
+
+dev = SwidgetDevice(
+    host="192.168.1.62",
+    token_name="x-secret-key",
+    secret_key="password",
+    use_https=True,
+    use_websockets=False,
+)
+await dev.update()
+img = await dev.get_snapshot_bytes(width=640, height=360)
+with open("snapshot.jpg", "wb") as f:
+    f.write(img)
+await dev.close()
+```
+
+Type checking
+-------------
+Run mypy in strict mode:
+```
+poetry run mypy --strict swidget
+```
+
+Docs build
+----------
+Generate HTML docs with Sphinx:
+```
+cd docs
+poetry run sphinx-build -b html . _build
+```

{python_swidget-1.3.2 → python_swidget-1.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-swidget"
-version = "1.3.2"
+version = "1.4.0"
 description = "Python API for Swidget smart devices"
 license = "GPL-3.0-or-later"
 authors = ["Swidget"]
@@ -22,9 +22,9 @@ importlib-metadata = "*"
 asyncclick = ">=8"
 pydantic = "^2"
 ssdp = "1.1.1"
-requests = "2.32.3"
-types-requests = "^2.3.0"
-urllib3 = '1.26.5'
+requests = "2.32.5"
+types-requests = "^2.32.0"
+urllib3 = '2.5.0'
 
 # required only for docs
 sphinx = { version = "^4", optional = true }
@@ -38,6 +38,7 @@ pytest = ">=6.2.5"
 pytest-cov = "^2"
 pytest-asyncio = "^0"
 pytest-sugar = "*"
+aioresponses = "^0.7.6"
 pre-commit = "*"
 voluptuous = "*"
 toml = "*"
@@ -46,6 +47,11 @@ pytest-mock = "^3"
 codecov = "^2"
 xdoctest = "^0"
 coverage = {version = "^6", extras = ["toml"]}
+sphinx = "^4"
+sphinx-autobuild = "^2021.3.14"
+sphinx-rtd-theme = "^1.2"
+mypy = "^1.11"
+black = "^24.4"
 
 [tool.poetry.extras]
 docs = ["sphinx", "sphinx_rtd_theme", "m2r", "mistune", "sphinxcontrib-programoutput"]

{python_swidget-1.3.2 → python_swidget-1.4.0}/swidget/__init__.py

@@ -12,7 +12,7 @@ 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 importlib_metadata import version
 
 from swidget.discovery import SwidgetDiscoveredDevice, discover_devices, discover_single
 from swidget.exceptions import SwidgetException

{python_swidget-1.3.2 → python_swidget-1.4.0}/swidget/cli.py

@@ -236,10 +236,10 @@ async def ping(dev):
     click.echo("Pinging the device")
     try:
         result = await dev.ping()
-        if result == 200:
+        if result:
             click.echo("Successfully pinged device")
         else:
-            click.echo(result.status_code)
+            click.echo("Unable to ping device")
     except Exception:
         click.echo("Unable to ping device")
 

{python_swidget-1.3.2 → python_swidget-1.4.0}/swidget/discovery.py

@@ -5,7 +5,7 @@ import socket
 from typing import Any, Type
 from urllib.parse import urlparse
 
-import ssdp  # type: ignore
+import ssdp
 
 from swidget.swidgetdevice import DeviceType, SwidgetDevice
 
@@ -31,12 +31,14 @@ class SwidgetDiscoveredDevice:
         host_type: str,
         insert_type: str,
         friendly_name: str = "Swidget Discovered Device",
+        host_id: str = "",
     ):
         self.mac = mac
         self.host = host
         self.friendly_name = friendly_name
         self.host_type = host_type
         self.insert_type = insert_type
+        self.host_id = host_id
 
 
 class SwidgetProtocol(ssdp.SimpleServiceDiscoveryProtocol):

python_swidget-1.4.0/swidget/exceptions.py

@@ -0,0 +1,13 @@
+"""Exception types for the python-swidget library."""
+
+
+class SwidgetException(Exception):
+    """Base exception for Swidget-related errors."""
+
+
+class SwidgetAuthenticationException(SwidgetException):
+    """Raised when device authentication fails (HTTP 403)."""
+
+
+class SwidgetConnectionException(SwidgetException):
+    """Raised when a connection to the device cannot be established."""

{python_swidget-1.3.2 → python_swidget-1.4.0}/swidget/swidgetdevice.py

@@ -9,8 +9,13 @@ from types import TracebackType
 from typing import Any, Dict, List, Optional
 
 from aiohttp import ClientSession, TCPConnector
+from aiohttp.client_exceptions import ClientConnectorError
 
-from .exceptions import SwidgetException
+from .exceptions import (
+    SwidgetAuthenticationException,
+    SwidgetConnectionException,
+    SwidgetException,
+)
 from .websocket import SwidgetWebsocket
 
 _LOGGER = logging.getLogger(__name__)
@@ -37,6 +42,8 @@ class InsertType(Enum):
     GL = "GUIDE LIGHT"
     PO = "POWER OUT"
     VIDEO = "video"  # This is not a mistake.
+    USBC = "USBC"
+    WD = "WATER DETECTOR"
     Unknown = -1
 
 
@@ -61,10 +68,16 @@ class SelfDiagnosticErrorCodes(Enum):
 
 
 class SwidgetDevice:
-    """Class to represent the Swidge device."""
+    """Core representation of a Swidget device (base class for all device types)."""
 
     def __init__(
-        self, host, token_name, secret_key, use_https=True, use_websockets=True
+        self,
+        host,
+        token_name,
+        secret_key,
+        use_https=True,
+        use_websockets=True,
+        verify_ssl: bool = False,
     ) -> None:
         self.token_name = token_name
         self.ip_address = host
@@ -72,13 +85,16 @@ class SwidgetDevice:
         self.uri_scheme = "https" if self.use_https is True else "http"
         self.secret_key = secret_key
         self.use_websockets = use_websockets
+        self.verify_ssl = verify_ssl
         self.device_type = DeviceType.Unknown
         self._friendly_name = "Unknown Swidget Device"
         self.assemblies: Dict[Any, Any] = dict()
         self.device_config: DeviceConfiguration = DeviceConfiguration({})
         self._subscribers: List[Any] = list()
         headers = {self.token_name: self.secret_key, "Connection": "keep-alive"}
-        connector = TCPConnector(verify_ssl=False, force_close=True)
+        # aiohttp recommends using ssl context; verify_ssl is deprecated.
+        ssl_flag = verify_ssl if use_https else False
+        connector = TCPConnector(ssl=ssl_flag, force_close=True)
         if use_https is True:
             self._session = ClientSession(headers=headers, connector=connector)
         else:
@@ -91,12 +107,14 @@ class SwidgetDevice:
                 secret_key=self.secret_key,
                 callback=self.message_callback,
                 session=self._session,
+                use_security=self.use_https,
+                verify_ssl=verify_ssl,
             )
 
     @property
     def connected(self) -> bool:
         """Property to represent if the client is connected to the device."""
-        return self._websocket.connected
+        return hasattr(self, "_websocket") and self._websocket.connected
 
     def get_websocket(self) -> Optional[SwidgetWebsocket]:
         """Return the SwidgetWebsocket class instance if possible."""
@@ -187,15 +205,112 @@ class SwidgetDevice:
         for callback in self._subscribers:
             await callback(message)
 
+    async def make_http_request(
+        self,
+        method: str,
+        endpoint: str,
+        params: Optional[Dict[str, Any]] = None,
+        json_payload: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Make a generic HTTP request to a specified device endpoint.
+
+        Args:
+            method: The HTTP method to use (e.g., "GET", "POST").
+            endpoint: The API endpoint to request (e.g., "summary", "state").
+            params: Optional dictionary of URL query parameters.
+            json_payload: Optional dictionary to send as a JSON request body.
+
+        Returns:
+            The JSON response from the device as a dictionary.
+
+        Raises:
+            SwidgetConnectionException: If there is a problem connecting.
+            SwidgetAuthenticationException: If the device returns a 403 error.
+            ValueError: If an unsupported HTTP method is provided.
+        """
+        http_method = method.upper()
+        if http_method not in ("GET", "POST"):
+            raise ValueError(f"Unsupported HTTP method: {http_method}")
+
+        url = f"{self.uri_scheme}://{self.ip_address}/api/v1/{endpoint}"
+        _LOGGER.debug(f"Sending {http_method} request to: {url}")
+
+        try:
+            async with self._session.request(
+                method=http_method,
+                url=url,
+                params=params,
+                json=json_payload,
+                ssl=self.verify_ssl if self.use_https else False,
+            ) as response:
+                if response.status == 200:
+                    if response.content_length == 0:
+                        return {}
+                    return await response.json()
+                elif response.status == 403:
+                    _LOGGER.error(
+                        f"Authentication failed for {http_method} '{endpoint}'"
+                    )
+                    raise SwidgetAuthenticationException
+                else:
+                    response.raise_for_status()
+                return {}
+        except ClientConnectorError as e:
+            _LOGGER.error(f"Connection error while requesting '{endpoint}': {e}")
+            raise SwidgetConnectionException from e
+
+    async def _make_passthrough_request(
+        self,
+        method: str,
+        path: str,
+        params: Optional[Dict[str, Any]] = None,
+    ) -> Any:
+        """Send a request to endpoints that are not part of the /api/v1/ namespace."""
+        http_method = method.upper()
+        url = f"{self.uri_scheme}://{self.ip_address}/{path.lstrip('/')}"
+        request_params = dict(params or {})
+        if (
+            self.secret_key
+            and self.token_name
+            and self.token_name not in request_params
+        ):
+            request_params[self.token_name] = self.secret_key
+
+        _LOGGER.debug(
+            f"Sending {http_method} request to: {url} with params {request_params}"
+        )
+
+        try:
+            async with self._session.request(
+                method=http_method,
+                url=url,
+                params=request_params,
+                ssl=self.verify_ssl if self.use_https else False,
+            ) as response:
+                if response.status == 200:
+                    if response.content_length == 0:
+                        return {}
+                    content_type = response.headers.get("Content-Type", "").lower()
+                    if "application/json" in content_type:
+                        return await response.json()
+                    # Fallback: return text (e.g., ping returns plain "PONG")
+                    text_body = await response.text()
+                    try:
+                        return json.loads(text_body)
+                    except Exception:
+                        return text_body
+                response.raise_for_status()
+                return {}
+        except ClientConnectorError as e:
+            _LOGGER.error(f"Connection error while requesting '{path}': {e}")
+            raise SwidgetConnectionException from e
+
     async def get_device_config(self) -> Any:
         """Get the config of the device."""
         _LOGGER.debug("SwidgetDevice.get_device_config() called")
         _LOGGER.debug("Sending get_summary() command over http")
-        async with self._session.get(
-            url=f"{self.uri_scheme}://{self.ip_address}/api/v1/device_config",
-            ssl=False,
-        ) as response:
-            config = await response.json()
+        config = await self.make_http_request("GET", "device_config")
         self.device_config = DeviceConfiguration(config)
         self._last_update = int(time.time())
 
@@ -211,10 +326,7 @@ class SwidgetDevice:
             )
         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()
+            summary = await self.make_http_request("GET", "summary")
             await self.process_summary(summary)
 
     async def process_summary(self, summary) -> None:
@@ -237,10 +349,7 @@ class SwidgetDevice:
         """Retrieve the friendly name of the device."""
         _LOGGER.debug("SwidgetDevice.get_friendly_name() called")
         try:
-            async with self._session.get(
-                url=f"{self.uri_scheme}://{self.ip_address}/api/v1/name", ssl=False
-            ) as response:
-                name = await response.json()
+            name = await self.make_http_request("GET", "name")
         except Exception:
             name = {"name": f"Swidget {self.device_type} w/{self.insert_type} insert"}
         await self.process_friendly_name(name["name"])
@@ -256,17 +365,14 @@ class SwidgetDevice:
         _LOGGER.debug("SwidgetDevice.get_state() called")
         if self.use_websockets:
             _LOGGER.debug(
-                "In websocket mode. Sending get_summary() command over websocket"
+                "In websocket mode. Sending get_state() 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()
+            _LOGGER.debug("In http mode. Sending get_state() command over http")
+            state = await self.make_http_request("GET", "state")
             await self.process_state(state)
 
     async def process_state(self, state) -> None:
@@ -277,7 +383,7 @@ class SwidgetDevice:
         try:
             self.rssi = state["connection"]["rssi"]
         except Exception:
-            pass
+            self.rssi = 0
         for assembly in self.assemblies:
             for id, component in self.assemblies[assembly].components.items():
                 try:
@@ -295,7 +401,7 @@ class SwidgetDevice:
             await self.get_state()
             if self._friendly_name == "Unknown Swidget Device":
                 await self.get_friendly_name()
-            if self.device_config == {}:
+            if not self.device_config.config_populated():
                 await self.get_device_config()
         elif (int(time.time()) - self._last_update) < 5:
             _LOGGER.debug("update() recently called, not executing")
@@ -307,10 +413,18 @@ class SwidgetDevice:
     async def send_config(self, payload: dict) -> None:
         """Send a config block to the device."""
         _LOGGER.debug("SwidgetDevice.send_config() called")
-        data = json.dumps(
-            {"type": "config", "request_id": "send_config", "payload": payload}
-        )
-        await self._websocket.send_str(data)
+        if self.use_websockets:
+            _LOGGER.debug(
+                "In websocket mode. Sending send_config() command over websocket"
+            )
+            data = json.dumps(
+                {"type": "config", "request_id": "send_config", "payload": payload}
+            )
+            await self._websocket.send_str(data)
+        else:
+            raise SwidgetException(
+                "Configuration management is not available via websocket."
+            )
 
     async def send_command(
         self, assembly: str, component: str, function: str, command: dict
@@ -327,16 +441,19 @@ class SwidgetDevice:
             await self._websocket.send_str(command_data)
         else:
             _LOGGER.debug("NOT in websocket mode, sending command over HTTP")
-            async with self._session.post(
-                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
+            response = await self.make_http_request(
+                "POST", "command", json_payload=data
+            )
+            if response:
+                try:
+                    function_value = response[assembly]["components"][component][
+                        function
+                    ]
+                    self.assemblies[assembly].components[component].functions[
+                        function
+                    ] = function_value
+                except Exception:
+                    _LOGGER.debug("Command response did not include state update")
 
     async def ping(self) -> bool:
         """Ping the device to ensure it's devices.
@@ -345,12 +462,9 @@ class SwidgetDevice:
         """
         _LOGGER.debug("SwidgetDevice.ping() called")
         try:
-            async with self._session.get(
-                url=f"{self.uri_scheme}://{self.ip_address}/ping", ssl=False
-            ) as response:
-                if response.status == 200:
-                    return True
-                return False
+            response = await self._make_passthrough_request("GET", "ping")
+            _LOGGER.debug(f"Ping response: {response}")
+            return True if response == {} else bool(response)
         except Exception:
             return False
 
@@ -360,13 +474,7 @@ 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"{self.uri_scheme}://{self.ip_address}/blink", ssl=False
-            ) as response:
-                return await response.json()
-        except Exception:
-            raise SwidgetException
+        return await self._make_passthrough_request("GET", "blink")
 
     async def enable_debug_server(self) -> Any:
         """Enable the Swidget local debug server.
@@ -374,30 +482,14 @@ class SwidgetDevice:
         :raises SwidgetException: Raise the exception if there we are unable to connect to the Swidget device
         """
         _LOGGER.debug("SwidgetDevice.enable_debug_server() called")
-        try:
-            async with self._session.get(
-                url=f"{self.uri_scheme}://{self.ip_address}/debug?x-secret-key={self.secret_key}",
-                ssl=False,
-            ) as response:
-                if response.status == 200:
-                    return True
-                return False
-        except Exception:
-            raise SwidgetException
+        return await self.make_http_request("GET", "debug")
 
     async def restart_device(self) -> Any:
         """Restart the Swidget device.
 
         :raises SwidgetException: Raise the exception if there we are unable to connect to the Swidget device
         """
-        try:
-
-            async with self._session.post(
-                url=f"{self.uri_scheme}://{self.ip_address}/api/v1/reset", ssl=False
-            ) as response:
-                return await response.json()
-        except Exception:
-            raise SwidgetException
+        return await self.make_http_request("POST", "reset")
 
     async def factory_reset(self) -> Any:
         """Factory reset the Swidget device.
@@ -419,12 +511,8 @@ class SwidgetDevice:
         :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:
-                newer_versions = await response.json()
-                return sorted(newer_versions["updates"])
+            newer_versions = await self.make_http_request("GET", "update")
+            return sorted(newer_versions["updates"])
         except Exception:
             raise SwidgetException
 
@@ -435,15 +523,10 @@ class SwidgetDevice:
         """
         try:
             data = {"version": version}
-            async with self._session.post(
-                url=f"{self.uri_scheme}://{self.ip_address}/api/v1/update/version",
-                ssl=False,
-                data=json.dumps(data),
-            ) as response:
-                result = response.status
-                if result == 200:
-                    return True
-                return False
+            response = await self.make_http_request(
+                "POST", "update/version", json_payload=data
+            )
+            return bool(response)
         except Exception:
             raise SwidgetException
 
@@ -544,6 +627,10 @@ class SwidgetDevice:
                 pass
             elif function == "sd":
                 return_values[function] = data["state"]
+            elif function == "water":
+                return_values[function] = data["state"]
+            elif function == "buzzer":
+                return_values[function] = data["mode"]
             else:
                 return_values[function] = data["now"]
         return return_values
@@ -752,7 +839,7 @@ class DeviceConfiguration:
 
     def config_populated(self) -> bool:
         """Return if configuration has been retrieved from the device."""
-        return self._config_dict == {}
+        return self._config_dict != {}
 
     @property
     def config(self):

{python_swidget-1.3.2 → python_swidget-1.4.0}/swidget/swidgetdimmer.py

@@ -27,7 +27,7 @@ class SwidgetDimmer(SwidgetDevice):
         )
         self.device_type = DeviceType.Dimmer
 
-    @property  # type: ignore
+    @property
     def brightness(self) -> int:
         """Return current brightness on dimmers.
 
@@ -66,7 +66,7 @@ class SwidgetDimmer(SwidgetDevice):
             command={"default": brightness},
         )
 
-    @property  # type: ignore
+    @property
     def is_dimmable(self) -> bool:
         """Whether the switch supports brightness changes."""
         _LOGGER.debug("SwidgetDimmer.is_dimmable() called")

{python_swidget-1.3.2 → python_swidget-1.4.0}/swidget/swidgettimerswitch.py

@@ -29,8 +29,8 @@ class SwidgetTimerSwitch(SwidgetSwitch):
         self._device_type = DeviceType.TimerSwitch
 
     async def set_countdown_timer(self, minutes) -> Any:
-        """Set the countdown timer."""
-        _LOGGER.debug("SwidgetTimerSwitch.set_brightness() called")
+        """Set the countdown timer in minutes."""
+        _LOGGER.debug("SwidgetTimerSwitch.set_countdown_timer() called")
         await self.send_command(
             assembly="host",
             component="0",

{python_swidget-1.3.2 → python_swidget-1.4.0}/swidget/websocket.py

@@ -26,6 +26,7 @@ class SwidgetWebsocket:
         callback: Union[Callable[[Any], None], Callable[[Any], Awaitable[None]]],
         session: aiohttp.ClientSession | None = None,
         use_security: bool = True,
+        verify_ssl: bool = False,
         retry_interval: int = 30,  # Initial retry interval in seconds
         max_retries: int | None = None,  # Maximum number of reconnection attempts
     ):
@@ -38,6 +39,7 @@ class SwidgetWebsocket:
             callback: A callable that will be called with received messages.
             session: An optional aiohttp.ClientSession to use.
             use_security: Whether to use wss:// (True) or ws:// (False).
+            verify_ssl: Whether to verify TLS when using wss://.
             retry_interval: Initial interval for reconnection attempts.
             max_retries: Maximum number of reconnection attempts.
         """
@@ -46,18 +48,18 @@ class SwidgetWebsocket:
         self.secret_key = secret_key or ""
         self.session = session or aiohttp.ClientSession()
         self.use_security = use_security
+        self._verify_ssl = verify_ssl
         self.callback = callback
         self.retry_interval = retry_interval
         self.max_retries = max_retries
         self.retry_count = 0
-        self._verify_ssl = False
         self.uri = self._get_uri()
 
         # self._client= None
         self.is_running = True
         self._closing = False
         self._client: ClientWebSocketResponse | None = None
-        self._receiver_task: asyncio.Task | None = None
+        self._receiver_task: asyncio.Task[Any] | None = None
         self._closing = False
 
     def _get_uri(self) -> str:
@@ -94,13 +96,13 @@ class SwidgetWebsocket:
             self.retry_count = 0
             _LOGGER.debug("Websocket now connected")
         except (ClientConnectionError, WSServerHandshakeError):
-            _LOGGER.error("Error connecting to websocket")
+            _LOGGER.exception("Error connecting to websocket")
             self._client = None
         except socket.gaierror as e:
             _LOGGER.error(f"Error resolving host: {e}")
             self._client = None
-        except Exception as e:
-            _LOGGER.error(f"An unexpected error occurred: {e}")
+        except Exception:
+            _LOGGER.exception("An unexpected error occurred.")
             self._client = None
 
     async def send_str(self, message: str) -> None:
@@ -126,7 +128,7 @@ class SwidgetWebsocket:
                         f"Failed to send message after {max_send_retries} attempts."
                     )
 
-    async def receive(self):
+    async def receive(self) -> Any | None:
         """Receive a message from the WebSocket server."""
         _LOGGER.debug("websocket.receive() called")
         try:
@@ -136,16 +138,17 @@ class SwidgetWebsocket:
                     message_data = message.json()
                     _LOGGER.debug(f"[{self.host}] Received message: {message_data}")
                     return message_data
-                elif message.type == WSMsgType.CLOSED:
-                    _LOGGER.error("Websocket client is closed")
+                elif message.type in (WSMsgType.CLOSED, WSMsgType.CLOSING):
+                    _LOGGER.error("Websocket connection is closed")
                     self._client = None
                 elif message.type == WSMsgType.ERROR:
                     _LOGGER.error("WebSocket error.")
                     self._client = None
         except Exception as e:
             _LOGGER.error(f"Error receiving message: {e}")
+        return None
 
-    async def close(self):
+    async def close(self) -> None:
         """Close the WebSocket connection."""
         _LOGGER.debug("websocket.close() called")
         self.is_running = False
@@ -156,15 +159,17 @@ class SwidgetWebsocket:
         if self.session and not self.session.closed:
             await self.session.close()
 
-    async def reconnect(self):
-        """Reconnect to the WebSocket server after a delay."""
+    async def reconnect(self) -> None:
+        """Attempt to reconnect to the WebSocket server, raising on failure."""
         _LOGGER.debug("websocket.reconnect() called")
         if self.max_retries is not None and self.retry_count >= self.max_retries:
-            _LOGGER.warning("Max retries reached. Stopping reconnect attempts.")
-            self.is_running = False
-            return
+            _LOGGER.error("Max retries reached. Stopping reconnect attempts.")
+            raise ConnectionError(
+                f"Max retries reached. Could not connect to {self.host}"
+            )
 
         self.retry_count += 1
+        # Implement exponential backoff for reconnection delay
         delay = self.retry_interval * (2 ** (self.retry_count - 1))
         _LOGGER.warning(
             f"Reconnecting to Swidget device: {self.host} in {delay} seconds (attempt {self.retry_count})..."
@@ -172,7 +177,7 @@ class SwidgetWebsocket:
         await asyncio.sleep(delay)
         await self.connect()
 
-    async def run(self):
+    async def run(self) -> None:
         """Run the WebSocket client to handle messages and reconnections."""
         while self.is_running:
             if self._client is None:
@@ -185,7 +190,7 @@ class SwidgetWebsocket:
                     else:
                         self.callback(message)
 
-    def status(self) -> dict:
+    def status(self) -> dict[str, Any]:
         """Return the current status of the websocket connection."""
         _LOGGER.debug("websocket.status() called")
         return {

python_swidget-1.3.2/PKG-INFO

@@ -1,55 +0,0 @@
-Metadata-Version: 2.3
-Name: python-swidget
-Version: 1.3.2
-Summary: Python API for Swidget smart devices
-License: GPL-3.0-or-later
-Author: Swidget
-Requires-Python: >=3.8,<4.0
-Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
-Classifier: Programming Language :: Python :: 3
-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
-Classifier: Programming Language :: Python :: 3.13
-Provides-Extra: docs
-Requires-Dist: aiohttp (>=3.8.1)
-Requires-Dist: anyio
-Requires-Dist: asyncclick (>=8)
-Requires-Dist: importlib-metadata
-Requires-Dist: m2r (>=0,<1) ; extra == "docs"
-Requires-Dist: mistune (<2.0.0) ; extra == "docs"
-Requires-Dist: pydantic (>=2,<3)
-Requires-Dist: requests (==2.32.3)
-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.3.0,<3.0.0)
-Requires-Dist: urllib3 (==1.26.5)
-Project-URL: Repository, https://github.com/swidget/python-swidget
-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.3.2/README.md

@@ -1,21 +0,0 @@
-# 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.3.2/swidget/exceptions.py

@@ -1,2 +0,0 @@
-class SwidgetException(Exception):
-    """Base exception for device errors."""