pywemo 1.4.0__py3-none-any.whl

pywemo/ouimeaux_device/maker.py

@@ -0,0 +1,54 @@
+"""Representation of a WeMo Maker device."""
+from __future__ import annotations
+
+from typing import TypedDict
+
+from .api.attributes import AttributeDevice
+from .api.service import RequiredService
+
+
+class _Attributes(TypedDict, total=False):
+    Switch: int
+    Sensor: int
+    SwitchMode: int
+    SensorPresent: int
+
+
+class Maker(AttributeDevice):
+    """Representation of a WeMo Maker device."""
+
+    _state_property = "switch_state"  # Required by AttributeDevice.
+    _attributes: _Attributes  # Required by AttributeDevice.
+
+    @property
+    def _required_services(self) -> list[RequiredService]:
+        return super()._required_services + [
+            RequiredService(name="basicevent", actions=["SetBinaryState"]),
+        ]
+
+    def set_state(self, state: int) -> None:
+        """Set the state of this device to on or off."""
+        # The Maker has a momentary mode - so it's not safe to assume
+        # the state is what you just set, so re-read it from the device
+        self.basicevent.SetBinaryState(BinaryState=int(state))
+        self.get_state(True)
+
+    @property
+    def switch_state(self) -> int:
+        """Return the state of the switch."""
+        return self._attributes["Switch"]
+
+    @property
+    def sensor_state(self) -> int:
+        """Return the state of the sensor."""
+        return self._attributes["Sensor"]
+
+    @property
+    def switch_mode(self) -> int:
+        """Return the switch mode of the sensor."""
+        return self._attributes["SwitchMode"]
+
+    @property
+    def has_sensor(self) -> int:
+        """Return whether the device has a sensor."""
+        return self._attributes["SensorPresent"]

pywemo/ouimeaux_device/motion.py

@@ -0,0 +1,6 @@
+"""Representation of a WeMo Motion device."""
+from . import Device
+
+
+class Motion(Device):
+    """Representation of a WeMo Motion device."""

pywemo/ouimeaux_device/outdoor_plug.py

@@ -0,0 +1,6 @@
+"""Representation of a WeMo OutdoorPlug device."""
+from .switch import Switch
+
+
+class OutdoorPlug(Switch):
+    """Representation of a WeMo Motion device."""

pywemo/ouimeaux_device/switch.py

@@ -0,0 +1,32 @@
+"""Representation of a WeMo Switch device."""
+from __future__ import annotations
+
+from . import Device
+from .api.service import RequiredService
+
+
+class Switch(Device):
+    """Representation of a WeMo Switch device."""
+
+    @property
+    def _required_services(self) -> list[RequiredService]:
+        return super()._required_services + [
+            RequiredService(name="basicevent", actions=["SetBinaryState"]),
+        ]
+
+    def set_state(self, state: int) -> None:
+        """Set the state of this device to on or off."""
+        self.basicevent.SetBinaryState(BinaryState=int(state))
+        self._state = int(state)
+
+    def off(self) -> None:
+        """Turn this device off. If already off, will return "Error"."""
+        self.set_state(0)
+
+    def on(self) -> None:  # pylint: disable=invalid-name
+        """Turn this device on. If already on, will return "Error"."""
+        self.set_state(1)
+
+    def toggle(self) -> None:
+        """Toggle the switch's state."""
+        self.set_state(not self.get_state())

pywemo/ssdp.py

@@ -0,0 +1,372 @@
+"""Module that implements SSDP protocol."""
+from __future__ import annotations
+
+import logging
+import re
+import select
+import socket
+import threading
+import time
+import uuid
+from datetime import datetime, timedelta
+from wsgiref.handlers import format_date_time
+
+from .ouimeaux_device.api.long_press import VIRTUAL_DEVICE_UDN
+from .util import get_callback_address, interface_addresses
+
+DISCOVER_TIMEOUT = 5
+
+LOG = logging.getLogger(__name__)
+
+RESPONSE_REGEX = re.compile(r"\n(.*)\: (.*)\r")
+
+MIN_TIME_BETWEEN_SCANS = timedelta(seconds=59)
+
+MULTICAST_GROUP = "239.255.255.250"
+MULTICAST_PORT = 1900
+
+# Wemo specific urn:
+ST = "urn:Belkin:service:basicevent:1"
+VIRTUAL_DEVICE_USN = f"{VIRTUAL_DEVICE_UDN}::{ST}"
+MAX_AGE = 86400
+
+SSDP_REPLY = f"""HTTP/1.1 200 OK
+CACHE-CONTROL: max-age={MAX_AGE}
+DATE: %(date)s
+EXT:
+LOCATION: http://%(callback)s/setup.xml
+OPT: "http://schemas.upnp.org/upnp/1/0/"; ns=01
+01-NLS: %(nls)s
+SERVER: Unspecified, UPnP/1.0, Unspecified
+X-User-Agent: pywemo
+ST: {ST}
+USN: {VIRTUAL_DEVICE_USN}
+
+"""  # Newline characters at the the end of SSDP_REPLY are intentional.
+SSDP_REPLY = SSDP_REPLY.replace("\n", "\r\n")
+
+SSDP_NOTIFY = f"""NOTIFY * HTTP/1.1
+HOST: {MULTICAST_GROUP}:{MULTICAST_PORT}
+CACHE-CONTROL: max-age={MAX_AGE}
+LOCATION: http://%(callback)s/setup.xml
+OPT: "http://schemas.upnp.org/upnp/1/0/"; ns=01
+01-NLS: %(nls)s
+NT: {ST}
+NTS: %(nts)s
+SERVER: Unspecified, UPnP/1.0, Unspecified
+X-User-Agent: pywemo
+USN: {VIRTUAL_DEVICE_USN}
+
+"""  # Newline characters at the the end of SSDP_NOTIFY are intentional.
+SSDP_NOTIFY = SSDP_NOTIFY.replace("\n", "\r\n")
+
+EXPECTED_ST_HEADER = ("ST: " + ST).encode("UTF-8")
+EXPECTED_MAN_HEADER = b'MAN: "ssdp:discover"'
+
+
+class UPNPEntry:
+    """Found uPnP entry."""
+
+    def __init__(self, values: dict[str, str]) -> None:
+        """Create a UPNPEntry object."""
+        self.values = values
+        self._created = datetime.now()
+        self._expires: datetime | None = None
+
+        if "cache-control" in self.values:
+            cache_seconds = int(self.values["cache-control"].split("=")[1])
+
+            self._expires = self._created + timedelta(seconds=cache_seconds)
+
+    @property
+    def st(self) -> str | None:  # pylint: disable=invalid-name
+        """Return ST value."""
+        return self.values.get("st")
+
+    @property
+    def location(self) -> str | None:
+        """Return location value."""
+        return self.values.get("location")
+
+    @property
+    def usn(self) -> str | None:
+        """Return unique service name."""
+        return self.values.get("usn")
+
+    @property
+    def udn(self) -> str:
+        """Return unique device name."""
+        usn = self.usn or ""
+        return usn.split("::")[0]
+
+    @classmethod
+    def from_response(cls, response: str) -> UPNPEntry:
+        """Create a uPnP entry from a response."""
+        return UPNPEntry(
+            {
+                key.lower(): item
+                for key, item in RESPONSE_REGEX.findall(response)
+            }
+        )
+
+    @property
+    def _key(self) -> tuple[str, str | None]:
+        """Tuple of values that uniquely identify the UPNPEntry instance."""
+        return (self.udn, self.location)
+
+    def __eq__(self, other: object) -> bool:
+        """Equality operator."""
+        return isinstance(other, type(self)) and self._key == other._key
+
+    def __hash__(self) -> int:
+        """Generate hash of instance."""
+        return hash(("UPNPEntry", self._key))
+
+    def __repr__(self) -> str:
+        """Return the string representation of the object."""
+        st = self.st or ""  # pylint: disable=invalid-name
+        location = self.location or ""
+        udn = self.udn or ""
+        return f"<UPNPEntry {st} - {location} - {udn}>"
+
+
+def build_ssdp_request(ssdp_st: str, ssdp_mx: int) -> bytes:
+    """Build the standard request to send during SSDP discovery."""
+    return "\r\n".join(
+        [
+            "M-SEARCH * HTTP/1.1",
+            f"ST: {ssdp_st}",
+            f"MX: {ssdp_mx}",
+            'MAN: "ssdp:discover"',
+            f"HOST: {MULTICAST_GROUP}:{MULTICAST_PORT}",
+            "",
+            "",
+        ]
+    ).encode("ascii")
+
+
+def scan(  # pylint: disable=too-many-branches,too-many-locals
+    st: str = ST,  # pylint: disable=invalid-name
+    timeout: float = DISCOVER_TIMEOUT,
+    max_entries: int | None = None,
+    match_udn: str | None = None,
+) -> list[UPNPEntry]:
+    """
+    Send a message over the network to discover upnp devices.
+
+    Inspired by Crimsdings ChromeCast code
+    https://github.com/crimsdings/  [ChromeCast repository since removed]
+    """
+    # pylint: disable=too-many-nested-blocks
+    ssdp_target = (MULTICAST_GROUP, MULTICAST_PORT)
+
+    entries: list[UPNPEntry] = []
+
+    calc_now = datetime.now
+
+    ssdp_request = build_ssdp_request(st, ssdp_mx=1)
+    sockets = []
+    try:
+        for addr in interface_addresses():
+            sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+            try:
+                sock.bind((addr, 0))
+                sock.sendto(ssdp_request, ssdp_target)
+                sockets.append(sock)
+            except OSError:
+                pass
+            finally:
+                if sock not in sockets:
+                    sock.close()
+
+        start = calc_now()
+        while sockets:
+            time_diff = calc_now() - start
+
+            seconds_left = max(timeout - time_diff.seconds, 0)
+
+            ready = select.select(sockets, [], [], min(1, seconds_left))[0]
+            if not ready:
+                # Only check for timeout when there are no more results. Exit
+                # if the time has expired, or probe again if there is more
+                # time remaining.
+                if seconds_left <= 0:
+                    return entries
+                for sock in sockets:
+                    sock.sendto(ssdp_request, ssdp_target)
+
+            for sock in ready:
+                response = sock.recv(1024).decode("UTF-8", "replace")
+
+                entry = UPNPEntry.from_response(response)
+                if entry.usn == VIRTUAL_DEVICE_USN:
+                    continue  # Don't return the virtual device.
+
+                # Search for devices
+                if entry not in entries:
+                    if match_udn is None:
+                        entries.append(entry)
+                    elif match_udn == entry.udn:
+                        entries.append(entry)
+
+                    # Return if we've found the max number of devices
+                    if max_entries and len(entries) == max_entries:
+                        return entries
+    except OSError:
+        LOG.exception("Socket error while discovering SSDP devices")
+    finally:
+        for sock in sockets:
+            sock.close()
+
+    return entries
+
+
+class DiscoveryResponder:
+    """Inform Wemo devices of the pywemo virtual Wemo device.
+
+    The DiscoveryResponder informs Wemo devices of the /setup.xml URL for the
+    pywemo virtual Wemo device. The virtual device is used for receiving long
+    press actions from Wemo devices and is integrated into the
+    SubscriptionRegistry HTTP server.
+
+    Wemo devices are informed of the pywemo virtual Wemo device in two ways:
+
+    1. Wemo devices periodically send UPnP M-SEARCH discovery requests for the
+    to locate other devices on the network. DiscoveryResponder responds to
+    these requests with the URL for the virtual device.
+
+    2. A UPnP NOTIFY message is periodically multicasted by DiscoveryResponder
+    to inform Wemo devices on the network of the URL for the virtual device.
+    """
+
+    def __init__(self, callback_port: int) -> None:
+        """Create a server that will respond to WeMo discovery requests.
+
+        Args:
+            callback_port: The port for the SubscriptionRegistry HTTP server.
+        """
+        self.callback_port = callback_port
+        self._thread: threading.Thread | None = None
+        self._exit = threading.Event()
+        self._thread_exception: Exception | None = None
+        self._notify_enabled = True  # Only ever set to False in tests.
+        self._nls_uuid = str(uuid.uuid4())
+
+    def send_notify(self, nts: str) -> None:
+        """Send a UPnP NOTIFY message containing the virtual device URL."""
+        ssdp_target = (MULTICAST_GROUP, MULTICAST_PORT)
+        for addr in interface_addresses():  # Send on all interfaces.
+            params = {
+                "callback": get_callback_address(addr, self.callback_port),
+                "nls": self._nls_uuid,
+                "nts": nts,
+            }
+            sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+            try:
+                sock.bind((addr, 0))
+                sock.sendto(
+                    (SSDP_NOTIFY % params).encode("UTF-8"), ssdp_target
+                )
+            except OSError:
+                pass
+            finally:
+                sock.close()
+
+    def respond_to_discovery(self) -> None:
+        """Respond to a WeMo discovery request with the virtual device URL."""
+        recv_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        send_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        try:
+            recv_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+
+            # Join the multicast group on all interfaces.
+            group = socket.inet_aton(MULTICAST_GROUP)
+            for addr in interface_addresses():
+                try:
+                    local = socket.inet_aton(addr)
+                    recv_sock.setsockopt(
+                        socket.IPPROTO_IP,
+                        socket.IP_ADD_MEMBERSHIP,
+                        group + local,
+                    )
+                except OSError as err:
+                    LOG.error(
+                        "Failed join multicast group on %s: %s", addr, err
+                    )
+
+            recv_sock.bind((MULTICAST_GROUP, MULTICAST_PORT))
+
+            next_notify = datetime.min
+            while not self._exit.is_set():
+                # Periodically send NOTIFY messages.
+                now = datetime.now()
+                if now > next_notify and self._notify_enabled:
+                    next_notify = now + timedelta(seconds=(MAX_AGE / 2) - 30)
+                    self.send_notify("ssdp:alive")
+
+                # Check for new discovery requests.
+                if not select.select([recv_sock], [], [], 1)[0]:
+                    continue  # Timeout, no data. Loop again and check for exit
+                msg, sock_addr = recv_sock.recvfrom(1024)
+                lines = msg.splitlines()
+                if len(lines) < 3 or not lines[0].startswith(
+                    b"M-SEARCH * HTTP"
+                ):
+                    continue
+                if (
+                    EXPECTED_ST_HEADER not in lines
+                    or EXPECTED_MAN_HEADER not in lines
+                ):
+                    continue
+                params = {
+                    "callback": get_callback_address(
+                        sock_addr[0], self.callback_port
+                    ),
+                    "date": format_date_time(time.time()),
+                    "nls": self._nls_uuid,
+                }
+                try:
+                    send_sock.sendto(
+                        (SSDP_REPLY % params).encode("UTF-8"), sock_addr
+                    )
+                except OSError as err:
+                    LOG.error(
+                        "Failed to send SSDP reply to %r: %s", sock_addr, err
+                    )
+
+            if self._notify_enabled:
+                self.send_notify("ssdp:byebye")
+        except Exception as exp:
+            self._thread_exception = exp  # Used in the stop() method.
+            raise
+        finally:
+            recv_sock.close()
+            send_sock.close()
+
+    def start(self) -> None:
+        """Start the server."""
+        self._exit.clear()
+        self._thread_exception = None
+        self._thread = threading.Thread(
+            target=self.respond_to_discovery,
+            name="Wemo DiscoveryResponder Thread",
+        )
+        self._thread.start()
+
+    def stop(self) -> None:
+        """Stop the server."""
+        if self._thread:
+            self._exit.set()
+            self._thread.join()
+            self._thread = None
+            # Improve visibility of any exceptions that occurred on the thread.
+            if self._thread_exception is not None:
+                # pylint: disable=raising-bad-type
+                raise self._thread_exception
+
+
+if __name__ == "__main__":
+    from pprint import pprint
+
+    pprint("Scanning UPNP..")
+    pprint(scan())