Merge remote-tracking branch 'upstream/master' into feat/smartcam_passthrough

kasa/cli/discover.py

@@ -123,14 +123,19 @@ async def list(ctx):
     async def print_discovered(dev: Device):
         cparams = dev.config.connection_type
         infostr = (
-            f"{dev.host:<15} {cparams.device_family.value:<20} "
-            f"{cparams.encryption_type.value:<7}"
+            f"{dev.host:<15} {dev.model:<9} {cparams.device_family.value:<20} "
+            f"{cparams.encryption_type.value:<7} {cparams.https:<5} "
+            f"{cparams.login_version or '-':<3}"
         )
         async with sem:
             try:
                 await dev.update()
             except AuthenticationError:
                 echo(f"{infostr} - Authentication failed")
+            except TimeoutError:
+                echo(f"{infostr} - Timed out")
+            except Exception as ex:
+                echo(f"{infostr} - Error: {ex}")
             else:
                 echo(f"{infostr} {dev.alias}")
 
@@ -138,7 +143,10 @@ async def list(ctx):
         if host := unsupported_exception.host:
             echo(f"{host:<15} UNSUPPORTED DEVICE")
 
-    echo(f"{'HOST':<15} {'DEVICE FAMILY':<20} {'ENCRYPT':<7} {'ALIAS'}")
+    echo(
+        f"{'HOST':<15} {'MODEL':<9} {'DEVICE FAMILY':<20} {'ENCRYPT':<7} "
+        f"{'HTTPS':<5} {'LV':<3} {'ALIAS'}"
+    )
     return await _discover(
         ctx,
         print_discovered=print_discovered,

kasa/module.py

@@ -159,6 +159,7 @@ class Module(ABC):
 
     # SMARTCAM only modules
     Camera: Final[ModuleName[smartcam.Camera]] = ModuleName("Camera")
+    LensMask: Final[ModuleName[smartcam.LensMask]] = ModuleName("LensMask")
 
     def __init__(self, device: Device, module: str) -> None:
         self._device = device

kasa/smartcam/modules/__init__.py

@@ -6,6 +6,7 @@ from .childdevice import ChildDevice
 from .device import DeviceModule
 from .homekit import HomeKit
 from .led import Led
+from .lensmask import LensMask
 from .matter import Matter
 from .pantilt import PanTilt
 from .time import Time
@@ -20,4 +21,5 @@ __all__ = [
     "Time",
     "HomeKit",
     "Matter",
+    "LensMask",
 ]

kasa/smartcam/modules/camera.py

@@ -1,16 +1,18 @@
-"""Implementation of device module."""
+"""Implementation of camera module."""
 
 from __future__ import annotations
 
 import base64
 import logging
 from enum import StrEnum
+from typing import Annotated
 from urllib.parse import quote_plus
 
 from ...credentials import Credentials
 from ...device_type import DeviceType
 from ...feature import Feature
 from ...json import loads as json_loads
+from ...module import FeatureAttribute, Module
 from ..smartcammodule import SmartCamModule
 
 _LOGGER = logging.getLogger(__name__)
@@ -29,28 +31,38 @@ class StreamResolution(StrEnum):
 class Camera(SmartCamModule):
     """Implementation of device module."""
 
-    QUERY_GETTER_NAME = "getLensMaskConfig"
-    QUERY_MODULE_NAME = "lens_mask"
-    QUERY_SECTION_NAMES = "lens_mask_info"
-
     def _initialize_features(self) -> None:
         """Initialize features after the initial update."""
-        self._add_feature(
-            Feature(
-                self._device,
-                id="state",
-                name="State",
-                attribute_getter="is_on",
-                attribute_setter="set_state",
-                type=Feature.Type.Switch,
-                category=Feature.Category.Primary,
+        if Module.LensMask in self._device.modules:
+            self._add_feature(
+                Feature(
+                    self._device,
+                    id="state",
+                    name="State",
+                    container=self,
+                    attribute_getter="is_on",
+                    attribute_setter="set_state",
+                    type=Feature.Type.Switch,
+                    category=Feature.Category.Primary,
+                )
             )
-        )
 
     @property
     def is_on(self) -> bool:
-        """Return the device id."""
-        return self.data["lens_mask_info"]["enabled"] == "off"
+        """Return the device on state."""
+        if lens_mask := self._device.modules.get(Module.LensMask):
+            return not lens_mask.enabled
+        return True
+
+    async def set_state(self, on: bool) -> Annotated[dict, FeatureAttribute()]:
+        """Set the device on state.
+
+        If the device does not support setting state will do nothing.
+        """
+        if lens_mask := self._device.modules.get(Module.LensMask):
+            # Turning off enables the privacy mask which is why value is reversed.
+            return await lens_mask.set_enabled(not on)
+        return {}
 
     def _get_credentials(self) -> Credentials | None:
         """Get credentials from ."""
@@ -109,14 +121,6 @@ class Camera(SmartCamModule):
         """Return the onvif url."""
         return f"http://{self._device.host}:{ONVIF_PORT}/onvif/device_service"
 
-    async def set_state(self, on: bool) -> dict:
-        """Set the device state."""
-        # Turning off enables the privacy mask which is why value is reversed.
-        params = {"enabled": "off" if on else "on"}
-        return await self._device._query_setter_helper(
-            "setLensMaskConfig", self.QUERY_MODULE_NAME, "lens_mask_info", params
-        )
-
     async def _check_supported(self) -> bool:
         """Additional check to see if the module is supported by the device."""
         return self._device.device_type is DeviceType.Camera

kasa/smartcam/modules/lensmask.py

@@ -0,0 +1,31 @@
+"""Implementation of lens mask privacy module."""
+
+from __future__ import annotations
+
+import logging
+
+from ..smartcammodule import SmartCamModule
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class LensMask(SmartCamModule):
+    """Implementation of lens mask module."""
+
+    REQUIRED_COMPONENT = "lensMask"
+
+    QUERY_GETTER_NAME = "getLensMaskConfig"
+    QUERY_MODULE_NAME = "lens_mask"
+    QUERY_SECTION_NAMES = "lens_mask_info"
+
+    @property
+    def enabled(self) -> bool:
+        """Return the lens mask state."""
+        return self.data["lens_mask_info"]["enabled"] == "on"
+
+    async def set_enabled(self, enable: bool) -> dict:
+        """Set the lens mask state."""
+        params = {"enabled": "on" if enable else "off"}
+        return await self._device._query_setter_helper(
+            "setLensMaskConfig", self.QUERY_MODULE_NAME, "lens_mask_info", params
+        )

kasa/smartcam/smartcamdevice.py

@@ -134,6 +134,11 @@ class SmartCamDevice(SmartDevice):
             if (
                 mod.REQUIRED_COMPONENT
                 and mod.REQUIRED_COMPONENT not in self._components
+                # Always add Camera module to cameras
+                and (
+                    mod._module_name() != Module.Camera
+                    or self._device_type is not DeviceType.Camera
+                )
             ):
                 continue
             module = mod(self, mod._module_name())