gh #192 updated the tapo multiple powerswitch things

Author: Anbukannadhasan

framework/core/powerModules/tapoControl.py

@@ -54,10 +54,10 @@
 from framework.core.powerModules.abstractPowerModule import PowerModuleInterface
 
 class powerTapo(PowerModuleInterface):
-    
+
     """Tapo power switch controller supports
     """
-    
+
     def __init__( self, log:logModule, ip:str, outlet:str = None, **kwargs ):
         """
         Tapo module based on kasa library.
@@ -71,13 +71,17 @@ def __init__( self, log:logModule, ip:str, outlet:str = None, **kwargs ):
         """
         super().__init__(log)
         self._is_on = False
-        self._outlet = None  # 0-based index if provided
+        self._outlet = None
         self.ip = ip
         self._username = kwargs.get("username", None)
         self._password = kwargs.get("password", None)
-        # Accept 0-based inputs (0,1,2,3...). Keep as string to match original style.
         if outlet is not None:
-            self._outlet = str(outlet).strip().strip("'\"")
+            cleaned = str(outlet).strip().strip("'\"")  # remove accidental quotes
+            try:
+                self._outlet = int(cleaned)             # keep numeric internally
+            except ValueError:
+                self._log.error("Invalid outlet value %r (cleaned=%r)", outlet, cleaned)
+
         self._device_type = None
         self._encryption_type = None
         self._discover_device()
@@ -106,18 +110,18 @@ def _performCommand(self, command, json = False, append_args:list = []):
         if self._password:
             command_list.append("--password")
             command_list.append(self._password)
-        #         if self._device_type != "UNKNOWN" and self._encryption_type:
-        #             command_list.append("--device-family")
-        #             command_list.append(self._device_type)
-        #             command_list.append("--encrypt-type")
-        #             command_list.append(self._encryption_type)
-        #         else:
-        #             if self._outlet is not None:
-        #                 command_list.append("--type")
-        #                 command_list.append("smart")
-        #             else:
-        #                 command_list.append("--type")
-        #                 command_list.append("plug")
+            if self._device_type != "UNKNOWN" and self._encryption_type:
+                command_list.append("--device-family")
+                command_list.append(self._device_type)
+                command_list.append("--encrypt-type")
+                command_list.append(self._encryption_type)
+            else:
+                if self._outlet:
+                    command_list.append("--type")
+                    command_list.append("strip")
+                else:
+                    command_list.append("--type")
+                    command_list.append("plug")
         command_list.append(command)
         for arg in append_args:
             command_list.append(arg)
@@ -157,64 +161,91 @@ def powerOn(self):
             return True
         if self._outlet is not None:
             self._performCommand("on", append_args=["--index", str(self._outlet)])
-        else:
-            self._performCommand("on")
+        self._performCommand("on")
         self._get_state()
         if self.is_on == False:
-            self._log.error(" Power On Failed")    
+            self._log.error(" Power On Failed")
         return self.is_on
 
     def _get_state(self):
-        """Get the state of the device."""
-        result = self._performCommand("state")
+        """Get the state of the device (or a specific outlet if configured)."""
 
-        if self._outlet is not None:
-            # 0-based outlet index requested by caller
+        # If no outlet configured, read the device-level flag and return.
+        if self._outlet is None:
+            result = self._performCommand("state")
+            if ("Device state: True" in result) or ("Device state: ON" in result):
+                self._is_on = True
+                self._log.debug("Device state: ON")
+            elif ("Device state: False" in result) or ("Device state: OFF" in result):
+                self._is_on = False
+                self._log.debug("Device state: OFF")
+            else:
+                # Conservative fallback if format is unexpected
+                self._is_on = False
+                self._log.debug("Device state: UNKNOWN → assuming OFF")
+            return
+
+        # OUTLET CONFIGURED — try JSON first (more reliable if supported).
+        try:
+            raw = self._performCommand("state", json=True)
+            data = json.loads(raw) if raw else None
+        except Exception:
+            data = None
+
+        if data:
+            # Common keys for children in different CLI versions
+            children = data.get("children") or data.get("plugs") or data.get("sockets") or []
             try:
-                idx0 = int(str(self._outlet).strip().strip("'\""))
+                idx = int(self._outlet)
             except Exception:
-                idx0 = -1
-                self._log.error("Invalid outlet index %r (must be integer >= 0)", self._outlet)
-
-            # Prefer P304M-style lines: "State (state): True/False" (one per child)
-            child_tf = re.findall(
-                r"^\s*State\s*\(state\)\s*:\s*(True|False)\s*$",
-                result,
-                flags=re.IGNORECASE | re.MULTILINE,
-            )
-            states = [s.lower() == "true" for s in child_tf]
-
-            # Fallback: "* Socket 'Plug X' state: ON/OFF ..."
-            if not states:
-                sockets = re.findall(
-                    r"^\*\s+Socket\s+'.*?'\s+state:\s+(ON|OFF)\b",
-                    result,
-                    flags=re.IGNORECASE | re.MULTILINE,
-                )
-                states = [s.upper() == "ON" for s in sockets]
-
-            if states and 0 <= idx0 < len(states):
-                self._is_on = bool(states[idx0])
-                self._log.debug("Slot state: %s", "ON" if self._is_on else "OFF")
+                self._log.error(f"Invalid outlet index {self._outlet!r}; defaulting to device state")
+                idx = -1
+
+            if 0 <= idx < len(children):
+                child = children[idx]
+                # Normalize child state (could be bool or string)
+                cstate = child.get("state", child.get("is_on", child.get("on")))
+                if isinstance(cstate, str):
+                    cstate = cstate.strip().lower() in ("on", "true", "1")
+                self._is_on = bool(cstate)
+                self._log.debug(f"Outlet {idx} state (json): {'ON' if self._is_on else 'OFF'}")
                 return
-
-            # Final fallback — device-level indicator
-            if "Device state: False" in result or "Device state: OFF" in result:
-                self._is_on = False
-                self._log.debug("Device state: OFF")
             else:
-                self._is_on = True
-                self._log.debug("Device state: ON")
- 
+                self._log.error(f"Outlet index {idx} out of range for JSON children (n={len(children)}). Falling back to text parse.")
+
+        # TEXT FALLBACK — matches the P304M output you shared.
+        result = self._performCommand("state")
+
+        # Collect child states in order they appear, e.g. lines like:
+        #   State (state): True
+        #   State (state): False
+        child_state_matches = re.findall(r"^\s*State\s*\(state\)\s*:\s*(True|False)\s*$",
+                                        result, flags=re.IGNORECASE | re.MULTILINE)
+        child_states = [(s.lower() == "true") for s in child_state_matches]
+
+        try:
+            idx = int(self._outlet)
+        except Exception:
+            self._log.error(f"Invalid outlet index {self._outlet!r}; falling back to device state.")
+            idx = -1
+
+        if 0 <= idx < len(child_states):
+            self._is_on = bool(child_states[idx])
+            self._log.debug(f"Outlet {idx} state (text): {'ON' if self._is_on else 'OFF'}")
             return
 
-        # No outlet configured — device-level logic
-        if "Device state: False" in result or "Device state: OFF" in result:
+        # Final fallback — device-level indicator if children couldn't be parsed or index OOR.
+        if ("Device state: True" in result) or ("Device state: ON" in result):
+            self._is_on = True
+        elif ("Device state: False" in result) or ("Device state: OFF" in result):
             self._is_on = False
-            self._log.debug("Device state: OFF")
         else:
-            self._is_on = True
-            self._log.debug("Device state: ON")
+            self._is_on = False  # conservative
+        self._log.error(
+            f"Could not parse outlet {idx} from text (children parsed={len(child_states)}). "
+            f"Falling back to device state: {'ON' if self._is_on else 'OFF'}"
+        )
+
 
     def _discover_device(self):
         command = ["kasa", "--json", "--target", str(self.ip)]
@@ -261,93 +292,74 @@ def _get_encryption_type(self):
 
     def getPowerLevel(self):
         """
-        - Single plug: use `emeter --json` (unchanged).
-        - Strip (outlet set, 0-based): try `feature current_consumption --index <outlet+1>`.
-        If unsupported/unavailable, raise the same RuntimeError as before to preserve behavior.
+        Return instantaneous power (Watts) via `feature current_consumption`.
+        Supports strips via --index <outlet>.
         """
-        # Per-outlet path (strip)
+        # --- normalize outlet inline (accept 0; strip accidental quotes) ---
+        idx_val = None
         if self._outlet is not None:
-            # Normalize 0-based outlet to CLI's 1-based index (defensive parsing)
-            try:
-                idx0 = int(str(self._outlet).strip().strip("'\""))
-                if idx0 < 0:
-                    raise ValueError
-                cli_index = idx0 + 1
-            except Exception:
-                # Keep previous contract: treat as unsupported for bad outlet input
-                raise RuntimeError("Power monitoring is not yet supported for Tapo strips")
-
-            args = ["current_consumption", "--index", str(cli_index)]
-
-            # 1) Try JSON first
-            try:
-                raw = self._performCommand("feature", json=True, append_args=args)
-            except Exception:
-                raw = None
-
-            if raw:
-                try:
-                    data = json.loads(raw)
-                    value = None
-                    if isinstance(data, (int, float, str)):
-                        value = data
-                    elif isinstance(data, dict):
-                        if "current_consumption" in data:
-                            cc = data["current_consumption"]
-                            if isinstance(cc, dict):
-                                value = cc.get("value")
-                                if value is None:
-                                    for k in ("w", "power", "power_w"):
-                                        v = cc.get(k)
-                                        if isinstance(v, (int, float, str)):
-                                            value = v
-                                            break
-                            else:
-                                value = cc
-                        elif "value" in data:
-                            value = data.get("value")
-                    if value is not None:
-                        return float(value)
-                except (json.JSONDecodeError, ValueError, TypeError):
-                    pass  # fall through to text
-
-            # 2) Text fallback
-            try:
-                text = self._performCommand("feature", append_args=args)
-            except Exception:
-                text = ""
-
-            m = re.search(
-                r"Current\s+consumption\s*\(current_consumption\)\s*:\s*([0-9]+(?:\.[0-9]+)?)\s*W",
-                text, flags=re.IGNORECASE
-            )
-            if m:
-                return float(m.group(1))
-
-            if re.search(r"Current\s+consumption\s*\(current_consumption\)\s*:\s*None\s*W",
-                        text, flags=re.IGNORECASE):
-                # Explicit "no live reading" — match prior semantics: treat as unsupported
-                raise RuntimeError("Power monitoring is not yet supported for Tapo strips")
-
-            # Preserve original behavior when feature/firmware doesn’t expose per-outlet power
-            raise RuntimeError("Power monitoring is not yet supported for Tapo strips")
-
-        # Device-level (single plug) — original behavior unchanged
-        result = self._performCommand("emeter", json=True)
+            cleaned = str(self._outlet).strip().strip("'\"")
+            if not cleaned.isdigit():
+                self._log.error(f"Invalid outlet value: {self._outlet!r}; querying device-level power instead.")
+            else:
+                idx_val = int(cleaned)
 
-        if not result:
-            raise ValueError("Received empty response from Tapo device for power monitoring")
+        # Build CLI args: feature current_consumption [--index N]
+        args = ["current_consumption"]
+        if idx_val is not None:
+            idx_token = f"{idx_val}"          # plain numeric string, no quotes
+            args += ["--index", idx_token]
 
+        # ---- 1) JSON first ----
+        raw = None
         try:
-            result = json.loads(result)
-        except json.JSONDecodeError as e:
-            raise ValueError(f"Failed to parse JSON from Tapo device response: {e}")
+            raw = self._performCommand("feature", json=True, append_args=args)
+        except Exception as e:
+            self._log.debug(f"feature current_consumption (json) call failed: {e}")
 
-        millewatt = result.get('power_mw')
-        if millewatt:
+        if raw:
             try:
-                power = int(millewatt) / 1000
-                return power
-            except Exception:
-                raise ValueError(f"Invalid value for power_mw: {millewatt}")
-        raise KeyError("The dictionary returned by the Tapo device does not contain a valid 'power_mw' value.")
+                data = json.loads(raw)
+                value = None
+                if isinstance(data, (int, float, str)):
+                    value = data
+                elif isinstance(data, dict):
+                    if "current_consumption" in data:
+                        cc = data["current_consumption"]
+                        if isinstance(cc, dict):
+                            value = cc.get("value")
+                            if value is None:
+                                for k in ("w", "power", "power_w"):
+                                    if isinstance(cc.get(k), (int, float, str)):
+                                        value = cc.get(k); break
+                        else:
+                            value = cc
+                    elif "value" in data:
+                        value = data.get("value")
+                if value is not None:
+                    watts = float(value)
+                    self._log.debug(f"current_consumption (json) = {watts} W")
+                    return watts
+            except (json.JSONDecodeError, TypeError, ValueError):
+                pass  # fall through to text
+
+        # ---- 2) Text fallback ----
+        try:
+            text = self._performCommand("feature", append_args=args)
+        except Exception as e:
+            raise RuntimeError(f"Failed to query current_consumption: {e}")
+
+        m = re.search(
+            r"Current\s+consumption\s*\(current_consumption\)\s*:\s*([0-9]+(?:\.[0-9]+)?)\s*W",
+            text, flags=re.IGNORECASE
+        )
+        if m:
+            watts = float(m.group(1))
+            self._log.debug(f"current_consumption (text) = {watts} W")
+            return watts
+
+        if re.search(r"Current\s+consumption\s*\(current_consumption\)\s*:\s*None\s*W",
+                    text, flags=re.IGNORECASE):
+            raise RuntimeError("Device returned 'None' for current consumption (no live reading).")
+
+        raise RuntimeError("current_consumption not available from device (feature missing or unsupported CLI/firmware).")

requirements.txt

@@ -34,7 +34,7 @@ jmespath==1.0.1
 marshmallow==3.21.1
 multidict==6.0.5
 netifaces==0.11.0
-numpy==1.26.4
+numpy>=2.0.0,<2.3.0
 opencv-python==4.9.0.80
 outcome==1.3.0.post0
 packaging==24.0
@@ -49,7 +49,7 @@ pyserial==3.5
 PySocks==1.7.1
 pytesseract==0.3.10
 python-dateutil==2.9.0.post0
-python-kasa==0.6.2.1
+python-kasa==0.7.7
 PyYAML==6.0.1
 requests==2.31.0
 requests-toolbelt==1.0.0
@@ -61,9 +61,9 @@ sortedcontainers==2.4.0
 soupsieve==2.5
 trio==0.25.0
 trio-websocket==0.11.1
-typing_extensions==4.10.0
+typing_extensions==4.12.2
 urllib3==1.26.18
 wcwidth==0.2.14
 wrapt==1.16.0
 wsproto==1.2.0
-yarl==1.9.4
+yarl==1.9.4