pywemo 1.4.0__py3-none-any.whl

pywemo/ouimeaux_device/api/attributes.py

@@ -0,0 +1,131 @@
+"""Attribute device helpers."""
+from __future__ import annotations
+
+import logging
+from typing import Any, get_type_hints
+
+from lxml import etree as et
+
+from ..switch import Switch
+from .service import RequiredService
+from .xsd_types import quote_xml
+
+LOG = logging.getLogger(__name__)
+
+
+class AttributeDevice(Switch):
+    """Handles all parsing/getting/setting of attribute lists.
+
+    This is intended to be used as the base class for all devices that support
+    the deviceevent.GetAttributes() method.
+
+    Subclasses can use the _attributes property to fetch the string values of
+    all attributes. Subclasses must provide the name of the property to use
+    for self._state in a property named _state_property. Subclasses must also
+    define a TypedDict to hold the attributes and add the TypedDict subclass as
+    a type hint for the _attributes property of the class.
+    """
+
+    EVENT_TYPE_ATTRIBUTE_LIST = "attributeList"
+
+    _state_property: str
+
+    _attr_name = "_attributes"
+    """Name of the TypedDict attribute that holds values for this device."""
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        """Create a Attributes device."""
+        assert isinstance(self._state_property, str)
+        setattr(self, self._attr_name, {})
+        class_hints = get_type_hints(type(self))
+        assert (attr_type := class_hints.get(self._attr_name)) is not None
+        self._attribute_type_hints = get_type_hints(attr_type)
+        super().__init__(*args, **kwargs)
+        self.update_attributes()
+
+    @property
+    def _required_services(self) -> list[RequiredService]:
+        return super()._required_services + [
+            RequiredService(
+                name="deviceevent", actions=["GetAttributes", "SetAttributes"]
+            ),
+        ]
+
+    def _update_attributes_dict(self, xml_blob: str) -> None:
+        xml_blob = "<attributes>" + xml_blob + "</attributes>"
+        xml_blob = xml_blob.replace("&gt;", ">")
+        xml_blob = xml_blob.replace("&lt;", "<")
+
+        for attribute in et.fromstring(
+            xml_blob, parser=et.XMLParser(resolve_entities=False)
+        ):
+            if len(attribute) < 2:
+                raise ValueError(
+                    f"Too few elements: {et.tostring(attribute).decode()}"
+                )
+            if (key := attribute[0].text) is None:
+                raise ValueError(
+                    f"Key is not present: {et.tostring(attribute[0]).decode()}"
+                )
+            if (value := attribute[1].text) is None:
+                raise ValueError(
+                    "Value is not present: "
+                    f"{et.tostring(attribute[1]).decode()}"
+                )
+
+            if (constructor := self._attribute_type_hints.get(key)) is None:
+                continue  # Ignore unexpected attributes
+            try:
+                getattr(self, self._attr_name)[key] = constructor(value)
+            except (TypeError, ValueError) as err:
+                raise ValueError(
+                    f"Unexpected value for {key}: {value}"
+                ) from err
+
+        state: int | None = getattr(self, self._state_property)
+        self._state = state
+
+    def update_attributes(self) -> None:
+        """Request state from device."""
+        resp = self.deviceevent.GetAttributes().get(
+            self.EVENT_TYPE_ATTRIBUTE_LIST
+        )
+        assert resp is not None
+        self._update_attributes_dict(resp)
+
+    def subscription_update(self, _type: str, _params: str) -> bool:
+        """Handle subscription push-events from device."""
+        if _type == self.EVENT_TYPE_ATTRIBUTE_LIST:
+            try:
+                self._update_attributes_dict(_params)
+            except (et.XMLSyntaxError, ValueError) as err:
+                LOG.error(
+                    "Unexpected %s value `%s` for device %s: %s",
+                    self.EVENT_TYPE_ATTRIBUTE_LIST,
+                    _params,
+                    self.name,
+                    repr(err),
+                )
+            return True
+
+        return super().subscription_update(_type, _params)
+
+    def get_state(self, force_update: bool = False) -> int:
+        """Return 0 if off and 1 if on."""
+        if force_update or self._state is None:
+            self.update_attributes()
+
+        assert self._state is not None
+        return self._state
+
+    def _set_attributes(self, *args: tuple[str, str | int | float]) -> None:
+        """Set the specified attributes on the device."""
+        attribute_xml = "</attribute><attribute>".join(
+            f"<name>{name}</name><value>{value}</value>"
+            for name, value in args
+        )
+        attribute_xml = f"<attribute>{attribute_xml}</attribute>"
+        self.deviceevent.SetAttributes(attributeList=quote_xml(attribute_xml))
+
+        # Refresh the device state
+        self.get_state(True)

pywemo/ouimeaux_device/api/db_orm.py

@@ -0,0 +1,197 @@
+"""Light-weight mapping between sqlite3 and python data structures."""
+import logging
+import sqlite3
+from typing import Any, Callable, Dict
+
+LOG = logging.getLogger(__name__)
+
+
+class DatabaseRow:
+    """Base class for sqlite Row schemas."""
+
+    TABLE_NAME: str
+    FIELDS: Dict[str, Callable[[Any], Any]]
+
+    def __init__(self, **kwargs):
+        """Initialize a row with the supplied values."""
+        for key, value in kwargs.items():
+            if key not in self.FIELDS:
+                raise AttributeError(
+                    f"{key} is not a valid attribute of {type(self).__name__}"
+                )
+            setattr(self, key, value)
+        self._modified = False
+
+    def __setattr__(self, name, value):
+        """Update one of the attributes of the Row."""
+        if name in self.FIELDS and value is not None:
+            super().__setattr__(name, self.FIELDS[name](value))
+        else:
+            super().__setattr__(name, value)
+        if name != "_modified":
+            super().__setattr__("_modified", True)
+
+    def __repr__(self):
+        """Return a string representation of the Row."""
+        values = []
+        for name in self.FIELDS.keys():
+            if hasattr(self, name):
+                values.append(f"{name}={repr(getattr(self, name))}")
+        class_name = self.__class__.__name__
+        values_str = ", ".join(values)
+        return f"{class_name}({values_str})"
+
+    def __eq__(self, other):
+        """Test for equality between two instances."""
+        return isinstance(other, self.__class__) and repr(self) == repr(other)
+
+    @property
+    def modified(self):
+        """Return True if any fields in the Row have been modified."""
+        return self._modified
+
+    @classmethod
+    def from_sqlite_row(cls, row):
+        """Initialize a Row from a sqllite cursor row."""
+        kwargs = {}
+        for key in row.keys():
+            kwargs[key] = row[key]
+        return cls(**kwargs)
+
+    @classmethod
+    def select_all(cls, cursor):
+        """Select all Row entries from the underlying sqlite table."""
+        names = ",".join(cls.FIELDS.keys())
+        cursor.execute(f"SELECT {names} FROM {cls.TABLE_NAME}")
+        for row in cursor.fetchall():
+            yield cls.from_sqlite_row(row)
+
+    @classmethod
+    def create_sqlite_table_from_row_schema(cls, cursor):
+        """Create a sqlite table based on the schema for this Row class."""
+        fields = []
+        for name, value in cls.FIELDS.items():
+            if isinstance(value, SQLType):
+                fields.append(f"{name} {value.sql_type}")
+            else:
+                value = SQLType.TYPE_MAP[value]
+                fields.append(f"{name} {value}")
+        fields_str = ", ".join(fields)
+        sql = f"CREATE TABLE {cls.TABLE_NAME}({fields_str})"
+        try:
+            cursor.execute(sql)
+        except sqlite3.Error:
+            LOG.exception("Query failed: %s", sql)
+            raise
+
+    def primary_key_name(self):
+        """Return the primary key for this Row."""
+        for name, value in self.FIELDS.items():
+            if isinstance(value, PrimaryKey):
+                return name
+        raise RuntimeError(f"No primary key for table {self.TABLE_NAME}")
+
+    def primary_key_value(self):
+        """Return the value of the primary key for this Row."""
+        return getattr(self, self.primary_key_name())
+
+    def update_db(self, cursor):
+        """Update the sqlite database to reflect any changes to this Row."""
+        column_list = []
+        values = []
+        for name in self.FIELDS.keys():
+            if hasattr(self, name):
+                column_list.append(name)
+                values.append(getattr(self, name))
+        column_list_str = ", ".join(column_list)
+        value_placeholders = ", ".join(["?"] * len(values))
+        sql = (
+            f"INSERT OR REPLACE INTO {self.TABLE_NAME} ({column_list_str}) "
+            f"VALUES ({value_placeholders})"
+        )
+        try:
+            cursor.execute(sql, values)
+        except sqlite3.Error:
+            LOG.exception("Query failed: %s %s", sql, values)
+            raise
+        try:
+            pk_name = self.primary_key_name()
+        except RuntimeError:
+            pass
+        else:
+            pk_type = self.FIELDS[pk_name]
+            if pk_type.auto_increment and not hasattr(self, pk_name):
+                setattr(self, pk_name, cursor.lastrowid)
+
+    def remove_from_db(self, cursor):
+        """Remove the Row from the sqlite database."""
+        pk_name = self.primary_key_name()
+        pk_value = self.primary_key_value()
+        if pk_value is None:
+            sql = f"DELETE FROM {self.TABLE_NAME} WHERE {pk_name} IS NULL"
+            values = ()
+        else:
+            sql = f"DELETE FROM {self.TABLE_NAME} WHERE {pk_name}=?"
+            values = (pk_value,)
+
+        try:
+            cursor.execute(sql, values)
+        except sqlite3.Error:
+            LOG.exception("Query failed: %s %s", sql, pk_value)
+            raise
+
+
+class SQLType:
+    """Base class for custom sqlite schema types."""
+
+    TYPE_MAP = {
+        int: "INTEGER",
+        float: "REAL",
+        str: "TEXT",
+    }
+
+    def __init__(self, type_constructor, *, sql_type=None, not_null=False):
+        """Create a SQLType.
+
+        Args:
+            type_constructor: Callable(value) that will receive the value from
+              the database cursor and convert it to a Python type.
+            sql_type: The sqlite field type.
+            not_null: Whether or not the sqlite field can be null.
+        """
+        self.type_constructor = type_constructor
+        self._sql_type = (
+            sql_type
+            if sql_type is not None
+            else SQLType.TYPE_MAP[type_constructor]
+        )
+        self.not_null = not_null
+
+    def __call__(self, value):
+        """Convert the sqlite row value to a Python type."""
+        return self.type_constructor(value)
+
+    @property
+    def sql_type(self):
+        """Return the sqlite type name for this type."""
+        if self.not_null:
+            return f"{self._sql_type} NOT NULL".lstrip()
+        return self._sql_type.lstrip()
+
+
+class PrimaryKey(SQLType):  # pylint: disable=too-few-public-methods
+    """Class used to indicate the primary key field for a Row."""
+
+    def __init__(self, *args, auto_increment=False, **kwargs):
+        """Create a PrimaryKey instance."""
+        super().__init__(*args, **kwargs)
+        self.auto_increment = auto_increment
+
+    @property
+    def sql_type(self):
+        """Return the sqlite type name for this type."""
+        value = super().sql_type
+        value = f"{value} PRIMARY KEY"
+        if self.auto_increment:
+            value = f"{value} AUTOINCREMENT"
+        return value.lstrip()

pywemo/ouimeaux_device/api/long_press.py

@@ -0,0 +1,168 @@
+"""Methods to make changes to the long press rules for a device.
+
+Wemo devices store a database of rules that configure actions for the device. A
+long press rule is activated when the button on the device is pressed for 2
+seconds. A person can press the button for 2 seconds and, based on the rules
+configured for the device, it will turn on/off/toggle other Wemo devices on the
+network. The methods in this mixin allow editing of the devices that are
+controlled by a long press.
+"""
+from __future__ import annotations
+
+import logging
+from enum import Enum
+from typing import Iterable, no_type_check
+
+from .rules_db import RuleDevicesRow, RulesDb, RulesRow, rules_db_from_device
+from .service import RequiredService, RequiredServicesMixin
+
+LOG = logging.getLogger(__name__)
+
+# RulesRow.Type values.
+RULE_TYPE_LONG_PRESS = "Long Press"
+
+VIRTUAL_DEVICE_UDN = "uuid:Socket-1_0-PyWemoVirtualDevice"
+
+
+class ActionType(Enum):
+    """Action to perform when a long press rule is triggered."""
+
+    TOGGLE = 2.0
+    ON = 1.0
+    OFF = 0.0
+
+
+@no_type_check
+def ensure_long_press_rule_exists(
+    rules_db: RulesDb, device_name: str, device_udn: str
+) -> RulesRow:
+    """Ensure that a long press rule exists and is enabled for the device.
+
+    Returns the long press rule.
+    """
+    current_rules = rules_db.rules_for_device(rule_type=RULE_TYPE_LONG_PRESS)
+    for rule, _ in current_rules:
+        if rule.State != "1":
+            LOG.info("Enabling long press rule for device %s", device_name)
+            rule.State = "1"
+            rule.update_db(rules_db.cursor())
+        return rule
+
+    LOG.info("Adding long press rule for device %s", device_name)
+    rule_orders = (
+        r.RuleOrder for r in rules_db.rules.values() if r.RuleOrder is not None
+    )
+    new_rule = RulesRow(
+        Name=f"{device_name} Long Press Rule",
+        Type=RULE_TYPE_LONG_PRESS,
+        RuleOrder=max(rule_orders, default=-1) + 1,
+        StartDate="12201982",
+        EndDate="07301982",
+        State="1",
+        Sync="NOSYNC",
+    )
+    rules_db.add_rule(new_rule)
+    rules_db.add_rule_devices(
+        RuleDevicesRow(
+            RuleID=new_rule.RuleID,  # pylint: disable=no-member
+            DeviceID=device_udn,
+            GroupID=0,
+            DayID=-1,
+            StartTime=60,
+            RuleDuration=86340,
+            StartAction=ActionType.TOGGLE.value,
+            EndAction=-1.0,
+            SensorDuration=-1,
+            Type=-1,
+            Value=-1,
+            Level=-1,
+            ZBCapabilityStart="",
+            ZBCapabilityEnd="",
+            OnModeOffset=-1,
+            OffModeOffset=-1,
+            CountdownTime=-1,
+            EndTime=86400,
+        )
+    )
+    return new_rule
+
+
+class LongPressMixin(RequiredServicesMixin):
+    """Methods to make changes to the long press rules for a device."""
+
+    EVENT_TYPE_LONG_PRESS = "LongPress"
+
+    @property
+    def _required_services(self) -> list[RequiredService]:
+        return super()._required_services + [
+            RequiredService(name="rules", actions=["FetchRules", "StoreRules"])
+        ]
+
+    @no_type_check
+    def list_long_press_udns(self) -> frozenset[str]:
+        """Return a list of device UDNs that are configured for long press."""
+        devices = []
+        with rules_db_from_device(self) as rules_db:
+            for rule, _ in rules_db.rules_for_device(
+                rule_type=RULE_TYPE_LONG_PRESS
+            ):
+                devices.extend(rules_db.get_target_devices_for_rule(rule))
+        return frozenset(devices)
+
+    @no_type_check
+    def add_long_press_udns(self, device_udns: Iterable[str]) -> None:
+        """Add a list of device UDNs to be configured for long press."""
+        with rules_db_from_device(self) as rules_db:
+            rule = ensure_long_press_rule_exists(rules_db, self.name, self.udn)
+            for udn in device_udns:
+                if not udn:
+                    continue
+                if udn not in rules_db.get_target_devices_for_rule(rule):
+                    rules_db.add_target_device_to_rule(rule, udn)
+
+    @no_type_check
+    def remove_long_press_udns(self, device_udns: Iterable[str]) -> None:
+        """Remove a list of device UDNs from the long press configuration."""
+        with rules_db_from_device(self) as rules_db:
+            for rule, _ in rules_db.rules_for_device(
+                rule_type=RULE_TYPE_LONG_PRESS
+            ):
+                for udn in device_udns:
+                    if udn in rules_db.get_target_devices_for_rule(rule):
+                        rules_db.remove_target_device_from_rule(rule, udn)
+
+    @no_type_check
+    def get_long_press_action(self) -> ActionType | None:
+        """Fetch the ActionType for the long press rule.
+
+        Will return None if no long press rule is configured for the device.
+        """
+        with rules_db_from_device(self) as rules_db:
+            for _, device in rules_db.rules_for_device(
+                rule_type=RULE_TYPE_LONG_PRESS
+            ):
+                return ActionType(device.StartAction)
+        return None
+
+    @no_type_check
+    def set_long_press_action(self, action: ActionType) -> None:
+        """Set the ActionType for the long press rule."""
+        with rules_db_from_device(self) as rules_db:
+            ensure_long_press_rule_exists(rules_db, self.name, self.udn)
+            for _, device in rules_db.rules_for_device(
+                rule_type=RULE_TYPE_LONG_PRESS
+            ):
+                device.StartAction = action.value
+
+    def ensure_long_press_virtual_device(self) -> None:
+        """Configure the device to notify pywemo when a long-press happens.
+
+        The ensure_long_press_virtual_device method ensures that the pywemo
+        virtual device is configured in the rules database for when a long
+        press rule is triggered.
+        """
+        self.add_long_press_udns([VIRTUAL_DEVICE_UDN])
+
+    def remove_long_press_virtual_device(self) -> None:
+        """Remove the pywemo virtual device from the long press."""
+        self.remove_long_press_udns([VIRTUAL_DEVICE_UDN])