homebridge-kasa-python 2.6.13 → 2.7.0-beta.0

package/dist/python/kasaApi.py

@@ -1,7 +1,7 @@
-import asyncio, eventlet, eventlet.wsgi, os, requests, sys
+import asyncio, eventlet, eventlet.wsgi, math, os, requests, sys
 from flask import Flask, request, jsonify
 from flask_socketio import SocketIO
-from kasa import Credentials, Discover, Device, UnsupportedDeviceError
+from kasa import Credentials, Discover, Device, Module, UnsupportedDeviceException
 from loguru import logger
 
 app = Flask(__name__)
@@ -21,17 +21,26 @@ logger.add(RemoteLogger(logging_server_url), level="DEBUG")
 
 app.logger = logger
 
-device_cache = {}
-
 UNSUPPORTED_TYPES = {
     'SMART.IPCAMERA',
-    'IOT.SMARTBULB',
     'SMART.KASAHUB',
-    'SMART.TAPOBULB',
     'SMART.TAPOHUB'
 }
 
-def custom_device_serializer(device: Device):
+def serialize_child(child: Device):
+    return {
+        "alias": child.alias,
+        **({"brightness": getattr(child.modules[Module.Light], "brightness")} if Module.Light in child.modules else {}),
+        **({"color_temp": getattr(child.modules[Module.Light], "color_temp")} if Module.Light in child.modules else {}),
+        **({"hsv": {
+            "hue": getattr(child.modules[Module.Light], "hsv")[0],
+            "saturation": getattr(child.modules[Module.Light], "hsv")[1]
+        }} if Module.Light in child.modules else {}),
+        "id": child.device_id.split("_", 1)[1],
+        "state": child.features["state"].value
+    }
+
+def custom_sysinfo_config_serializer(device: Device):
     app.logger.debug(f"Serializing device: {device.host}")
 
     child_num = len(device.children) if device.children else 0
@@ -43,26 +52,31 @@ def custom_device_serializer(device: Device):
         "device_type": device.config.connection_type.device_family.value,
         "host": device.host,
         "hw_ver": device.hw_info["hw_ver"],
-        "is_off": device.is_off,
-        "is_on": device.is_on,
         "mac": device.hw_info["mac"],
         "sw_ver": device.sys_info.get("sw_ver") or device.sys_info.get("fw_ver")
     }
 
     if child_num > 0:
-        sys_info["children"] = [
-            {
-                "id": child.device_id.split("_", 1)[1],
-                "state": child.features["state"].value,
-                "alias": child.alias
-            } for child in device.children
-        ]
+        sys_info["children"] = [serialize_child(child) for child in device.children]
     else:
-        sys_info["state"] = device.features["state"].value
+        sys_info.update({
+            "state": device.features["state"].value,
+            **({"brightness": getattr(device.modules[Module.Light], "brightness")} if Module.Light in device.modules else {}),
+            **({"color_temp": getattr(device.modules[Module.Light], "color_temp")} if Module.Light in device.modules else {}),
+            **({"hsv": {
+                "hue": getattr(device.modules[Module.Light], "hsv")[0],
+                "saturation": getattr(device.modules[Module.Light], "hsv")[1]
+            }} if Module.Light in device.modules else {})
+        })
 
     device_config = {
         "host": device.config.host,
         "timeout": device.config.timeout,
+        **({"credentials": {
+            "username": device.config.credentials.username,
+            "password": device.config.credentials.password
+        }} if device.config.credentials else {
+        }),
         "connection_type": {
             "device_family": device.config.connection_type.device_family.value,
             "encryption_type": device.config.connection_type.encryption_type.value,
@@ -71,25 +85,27 @@ def custom_device_serializer(device: Device):
         "uses_http": device.config.uses_http
     }
 
-    if device.config.credentials:
-        device_config["credentials"] = {
-            "username": device.config.credentials.username,
-            "password": device.config.credentials.password
-        }
-
     return {
         "sys_info": sys_info,
         "device_config": device_config
     }
 
-def custom_discovery_serializer(device: Device):
+def custom_discovery_feature_serializer(device: Device):
     app.logger.debug(f"Serializing device for discovery: {device.host}")
     disc_info = {
         "model": device._discovery_info.get("device_model", device.sys_info.get("model"))
     }
 
+    app.logger.debug(f"Serializing device features: {device.host}")
+    feature_info = {
+        **({"brightness": device.modules[Module.Light].is_dimmable} if Module.Light in device.modules else {}),
+        **({"color_temp": device.modules[Module.Light].is_variable_color_temp} if Module.Light in device.modules else {}),
+        **({"hsv": device.modules[Module.Light].is_color} if Module.Light in device.modules else {})
+    }
+
     return {
-        "disc_info": disc_info
+        "disc_info": disc_info,
+        "feature_info": feature_info
     }
 
 async def discover_devices(username=None, password=None, additional_broadcasts=None, manual_devices=None):
@@ -101,8 +117,8 @@ async def discover_devices(username=None, password=None, additional_broadcasts=N
     async def on_discovered(device: Device):
         try:
             await device.update()
-            app.logger.debug(f"Discovered device: {device.host}")
-        except UnsupportedDeviceError as e:
+            app.logger.debug(f"Discovered device has been updated: {device.host}")
+        except UnsupportedDeviceException as e:
             app.logger.warning(f"Unsupported device found during discovery: {device.host} - {str(e)}")
         except Exception as e:
             app.logger.error(f"Error updating device during discovery: {device.host} - {str(e)}")
@@ -112,26 +128,27 @@ async def discover_devices(username=None, password=None, additional_broadcasts=N
             app.logger.debug(f"Starting discovery on broadcast: {broadcast}")
             discovered_devices = await Discover.discover(target=broadcast, credentials=creds, on_discovered=on_discovered)
             for ip, dev in discovered_devices.items():
-                devices[ip] = dev
-                app.logger.debug(f"Added device {ip} from broadcast {broadcast} to devices list")
+                if ip not in devices:
+                    devices[ip] = dev
+                    app.logger.debug(f"Added device {ip} from broadcast {broadcast} to devices list")
             app.logger.debug(f"Discovered {len(discovered_devices)} devices on broadcast {broadcast}")
         except Exception as e:
             app.logger.error(f"Error processing broadcast {broadcast}: {str(e)}", exc_info=True)
 
     async def discover_manual_device(host):
         if host in devices:
-            app.logger.debug(f"Manual device {host} already exists in devices, skipping.")
+            app.logger.debug(f"Device {host} already exists in devices list, skipping.")
             return
         try:
-            app.logger.debug(f"Discovering manual device: {host}")
+            app.logger.debug(f"Starting discovery for device: {host}")
             discovered_device = await Discover.discover_single(host=host, credentials=creds)
-            await discovered_device.update()
+            await on_discovered(discovered_device)
             devices[host] = discovered_device
-            app.logger.debug(f"Discovered manual device: {host} with device type {discovered_device.device_type}")
-        except UnsupportedDeviceError as e:
-            app.logger.warning(f"Unsupported device found during manual discovery: {host} - {str(e)}")
+            app.logger.debug(f"Discovered device: {host}")
+        except UnsupportedDeviceException as e:
+            app.logger.warning(f"Unsupported device found during discovery: {host} - {str(e)}")
         except Exception as e:
-            app.logger.error(f"Error discovering manual device {host}: {str(e)}", exc_info=True)
+            app.logger.error(f"Error discovering device {host}: {str(e)}", exc_info=True)
 
     await asyncio.gather(*(discover_on_broadcast(broadcast) for broadcast in broadcasts))
     await asyncio.gather(*(discover_manual_device(host) for host in manual_devices))
@@ -145,7 +162,7 @@ async def discover_devices(username=None, password=None, additional_broadcasts=N
             components = await dev._raw_query("component_nego")
             component_list = components.get("component_nego", {}).get("component_list", [])
             homekit_component = next((item for item in component_list if item.get("id") == "homekit"), None)
-            if not dev.alias and homekit_component:
+            if homekit_component:
                 app.logger.debug(f"Native HomeKit Support found for device {ip} and was not added to update tasks")
                 continue
         except Exception:
@@ -154,10 +171,10 @@ async def discover_devices(username=None, password=None, additional_broadcasts=N
         try:
             dev_type = dev.sys_info.get("mic_type") or dev.sys_info.get("type")
             if dev_type and dev_type not in UNSUPPORTED_TYPES:
-                tasks.append(update_device_info(ip, dev))
-                app.logger.debug(f"Device {ip} with type {dev_type} added to update tasks")
+                tasks.append(create_device_info(ip, dev))
+                app.logger.debug(f"Device {ip} added to update tasks")
             else:
-                app.logger.debug(f"Device {ip} with type {dev_type} is unsupported and was not added to update tasks")
+                app.logger.debug(f"Device {ip} is unsupported and was not added to update tasks")
         except Exception as e:
             app.logger.error(f"Error adding device {ip} to update tasks: {str(e)}")
 
@@ -173,23 +190,26 @@ async def discover_devices(username=None, password=None, additional_broadcasts=N
     app.logger.debug(f"Device discovery completed with {len(all_device_info)} devices found")
     return all_device_info
 
-async def update_device_info(ip, dev: Device):
-    app.logger.debug(f"Updating device info for {ip}")
+async def create_device_info(ip, dev: Device):
+    created_device_info = {}
+    app.logger.debug(f"Creating device info for {ip}")
     try:
-        device = custom_device_serializer(dev)
-        sys_info = device["sys_info"]
-        device_config = device["device_config"]
-        device = custom_discovery_serializer(dev)
-        disc_info = device["disc_info"]
-        device_cache[ip] = {
+        device_info = custom_sysinfo_config_serializer(dev)
+        sys_info = device_info["sys_info"]
+        device_config = device_info["device_config"]
+        device_info = custom_discovery_feature_serializer(dev)
+        disc_info = device_info["disc_info"]
+        feature_info = device_info["feature_info"]
+        created_device_info[ip] = {
             "sys_info": sys_info,
             "disc_info": disc_info,
+            "feature_info": feature_info,
             "device_config": device_config
         }
-        app.logger.debug(f"Updated device info for {ip}")
-        return ip, device_cache[ip]
+        app.logger.debug(f"Created device info for {ip}")
+        return ip, created_device_info[ip]
     except Exception as e:
-        app.logger.error(f"Error updating device info for {ip}: {str(e)}")
+        app.logger.error(f"Error creating device info for {ip}: {str(e)}")
         return ip, {}
 
 async def get_sys_info(device_config):
@@ -200,7 +220,7 @@ async def get_sys_info(device_config):
             app.logger.warning(f"Alias not found for device {dev.host}. Reconnecting and updating...")
             await dev.disconnect()
             dev = await Device.connect(config=Device.Config.from_dict(device_config))
-        device = custom_device_serializer(dev)
+        device = custom_sysinfo_config_serializer(dev)
         sys_info = device["sys_info"]
         return {"sys_info": sys_info}
     except Exception as e:
@@ -209,27 +229,55 @@ async def get_sys_info(device_config):
     finally:
         await dev.disconnect()
 
-async def control_device(device_config, action, child_num=None):
-    if child_num is not None:
-        app.logger.debug(f"Controlling device: {device_config['host']}, action: {action}, child_num: {child_num}")
-    else:
-        app.logger.debug(f"Controlling device: {device_config['host']}, action: {action}")
+async def control_device(device_config, feature, action, value, child_num=None):
+    app.logger.debug(f"Controlling device: {device_config['host']}, feature: {feature}, action: {action}, child_num: {child_num if child_num is not None else 'N/A'}")
 
     dev = await Device.connect(config=Device.Config.from_dict(device_config))
     try:
-        if child_num is not None:
-            child = dev.children[child_num]
-            await getattr(child, action)()
+        target = dev.children[child_num] if child_num is not None else dev
+
+        if feature == "state":
+            await getattr(target, action)()
+        elif feature == "brightness":
+            await handle_brightness(target, action, value)
+        elif feature == "color_temp":
+            await handle_color_temp(target, action, value)
+        elif feature in ["hue", "saturation"]:
+            await handle_hsv(target, action, feature, value)
         else:
-            await getattr(dev, action)()
-        app.logger.debug(f"Controlled device {device_config['host']} with action: {action}")
-        return {"status": "success", f"is_{action.split('_')[1]}": True}
+            raise Exception(f"Unsupported feature: {feature}")
+
+        app.logger.debug(f"Controlled device {device_config['host']} with feature: {feature}, action: {action}, child_num: {child_num if child_num is not None else 'N/A'}")
+        return {"status": "success"}
     except Exception as e:
         app.logger.error(f"Error controlling device {device_config['host']}: {str(e)}")
         return {"status": "error", "message": str(e)}
     finally:
         await dev.disconnect()
 
+async def handle_brightness(target: Device, action, value):
+    if value == 0:
+        await target.turn_off()
+    elif value > 0 and value < 100:
+        light = target.modules[Module.Light]
+        await getattr(light, action)(value)
+    else:
+        await target.turn_on()
+
+async def handle_color_temp(target: Device, action, value):
+    light = target.modules[Module.Light]
+    range = light.valid_temperature_range
+    if value < range[0]:
+        value = range[0]
+    elif value > range[1]:
+        value = range[1]
+    await getattr(light, action)(value)
+
+async def handle_hsv(target: Device, action, feature, value):
+    light = target.modules[Module.Light]
+    hsv_value = {feature: value[feature]}
+    await getattr(light, action)(hsv_value)
+
 def run_async(func, *args):
     loop = asyncio.get_event_loop()
     return loop.run_until_complete(func(*args))
@@ -266,10 +314,12 @@ def control_device_route():
     device_config = data['device_config']
     credentials = device_config.get('credentials')
     device_config.update({'credentials': Credentials(username=credentials['username'], password=credentials['password'])} if credentials else {})
+    feature = data['feature']
     action = data['action']
+    value = data['value']
     child_num = data.get('child_num')
     app.logger.debug(f"Controlling device: {device_config['host']}, action: {action}, child_num: {child_num}")
-    result = run_async(control_device, device_config, action, child_num)
+    result = run_async(control_device, device_config, feature, action, value, child_num)
     return jsonify(result)
 
 @app.route('/health', methods=['GET'])

package/package.json

@@ -1,7 +1,7 @@
 {
   "displayName": "Homebridge Kasa Python",
   "name": "homebridge-kasa-python",
-  "version": "2.6.13",
+  "version": "2.7.0-beta.0",
   "description": "Plugin that uses Python-Kasa API to communicate with Kasa Devices.",
   "license": "MIT",
   "type": "module",
@@ -13,7 +13,7 @@
     "url": "https://github.com/ZeliardM/homebridge-kasa-python/issues"
   },
   "engines": {
-    "node": "^18.20.5 || ^20.18.1 || ^22.11.0 || ^23.3.0",
+    "node": "^18.20.5 || ^20.18.1 || ^22.12.0 || ^23.3.0",
     "homebridge": "^1.8.0 || ^2.0.0-beta.0",
     "python": "^3.9.0"
   },
@@ -47,20 +47,20 @@
   ],
   "devDependencies": {
     "@eslint/eslintrc": "^3.2.0",
-    "@eslint/js": "^9.15.0",
+    "@eslint/js": "^9.16.0",
     "@stylistic/eslint-plugin": "^2.11.0",
     "@types/lodash.defaults": "^4.2.9",
-    "@types/node": "^22.9.1",
+    "@types/node": "^22.10.1",
     "@types/semver": "^7.5.8",
-    "@typescript-eslint/parser": "^8.15.0",
-    "eslint": "^9.15.0",
-    "globals": "^15.12.0",
+    "@typescript-eslint/parser": "^8.17.0",
+    "eslint": "^9.16.0",
+    "globals": "^15.13.0",
     "homebridge": "^2.0.0-beta.23",
     "nodemon": "^3.1.7",
     "node-persist": "^4.0.3",
     "rimraf": "^6.0.1",
     "ts-node": "^10.9.2",
-    "typescript-eslint": "^8.15.0"
+    "typescript-eslint": "^8.17.0"
   },
   "homepage": "https://github.com/ZeliardM/homebridge-kasa-python#readme",
   "funding": [
@@ -76,12 +76,12 @@
   "dependencies": {
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
-    "axios": "^1.7.7",
+    "axios": "^1.7.9",
     "get-port": "^7.1.0",
     "lodash.defaults": "^4.2.0",
     "semver": "^7.6.3",
     "ts-essentials": "^10.0.3",
-    "typescript": "^5.6.3",
+    "typescript": "^5.7.2",
     "util": "^0.12.5"
   },
   "overrides": {

package/requirements.txt

@@ -2,5 +2,5 @@ eventlet==0.38.0
 flask==3.1.0
 flask_socketio==5.4.1
 loguru==0.7.2
-requests==2.32.3
-python-kasa==0.7.7
+python-kasa==0.8.0
+requests==2.32.3