Fix typing for wemo

.strict-typing

@@ -151,6 +151,7 @@ homeassistant.components.water_heater.*
 homeassistant.components.watttime.*
 homeassistant.components.weather.*
 homeassistant.components.websocket_api.*
+homeassistant.components.wemo.*
 homeassistant.components.zodiac.*
 homeassistant.components.zeroconf.*
 homeassistant.components.zone.*

homeassistant/components/wemo/__init__.py

@@ -1,7 +1,9 @@
 """Support for WeMo device discovery."""
 from __future__ import annotations
 
+from collections.abc import Sequence
 import logging
+from typing import Any, Optional, Tuple
 
 import pywemo
 import voluptuous as vol
@@ -14,10 +16,11 @@
 from homeassistant.components.switch import DOMAIN as SWITCH_DOMAIN
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_DISCOVERY, EVENT_HOMEASSISTANT_STOP
-from homeassistant.core import HomeAssistant, callback
+from homeassistant.core import CALLBACK_TYPE, Event, HomeAssistant, callback
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.dispatcher import async_dispatcher_send
 from homeassistant.helpers.event import async_call_later
+from homeassistant.helpers.typing import ConfigType
 from homeassistant.util.async_ import gather_with_concurrency
 
 from .const import DOMAIN
@@ -44,21 +47,20 @@
 
 _LOGGER = logging.getLogger(__name__)
 
+HostPortTuple = Tuple[str, Optional[int]]
 
-def coerce_host_port(value):
+
+def coerce_host_port(value: str) -> HostPortTuple:
     """Validate that provided value is either just host or host:port.
 
     Returns (host, None) or (host, port) respectively.
     """
-    host, _, port = value.partition(":")
+    host, _, port_str = value.partition(":")
 
     if not host:
         raise vol.Invalid("host cannot be empty")
 
-    if port:
-        port = cv.port(port)
-    else:
-        port = None
+    port = cv.port(port_str) if port_str else None
 
     return host, port
 
@@ -82,7 +84,7 @@ def coerce_host_port(value):
 )
 
 
-async def async_setup(hass, config):
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up for WeMo devices."""
     hass.data[DOMAIN] = {
         "config": config.get(DOMAIN, {}),
@@ -112,11 +114,11 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     discovery_responder = pywemo.ssdp.DiscoveryResponder(registry.port)
     await hass.async_add_executor_job(discovery_responder.start)
 
-    static_conf = config.get(CONF_STATIC, [])
+    static_conf: Sequence[HostPortTuple] = config.get(CONF_STATIC, [])
     wemo_dispatcher = WemoDispatcher(entry)
     wemo_discovery = WemoDiscovery(hass, wemo_dispatcher, static_conf)
 
-    async def async_stop_wemo(event):
+    async def async_stop_wemo(event: Event) -> None:
         """Shutdown Wemo subscriptions and subscription thread on exit."""
         _LOGGER.debug("Shutting down WeMo event subscriptions")
         await hass.async_add_executor_job(registry.stop)
@@ -142,8 +144,8 @@ class WemoDispatcher:
     def __init__(self, config_entry: ConfigEntry) -> None:
         """Initialize the WemoDispatcher."""
         self._config_entry = config_entry
-        self._added_serial_numbers = set()
-        self._loaded_components = set()
+        self._added_serial_numbers: set[str] = set()
+        self._loaded_components: set[str] = set()
 
     async def async_add_unique_device(
         self, hass: HomeAssistant, wemo: pywemo.WeMoDevice
@@ -191,16 +193,16 @@ def __init__(
         self,
         hass: HomeAssistant,
         wemo_dispatcher: WemoDispatcher,
-        static_config: list[tuple[[str, str | None]]],
+        static_config: Sequence[HostPortTuple],
     ) -> None:
         """Initialize the WemoDiscovery."""
         self._hass = hass
         self._wemo_dispatcher = wemo_dispatcher
-        self._stop = None
+        self._stop: CALLBACK_TYPE | None = None
         self._scan_delay = 0
         self._static_config = static_config
 
-    async def async_discover_and_schedule(self, *_) -> None:
+    async def async_discover_and_schedule(self, *_: tuple[Any]) -> None:
         """Periodically scan the network looking for WeMo devices."""
         _LOGGER.debug("Scanning network for WeMo devices")
         try:
@@ -229,7 +231,7 @@ def async_stop_discovery(self) -> None:
             self._stop()
             self._stop = None
 
-    async def discover_statics(self):
+    async def discover_statics(self) -> None:
         """Initialize or Re-Initialize connections to statically configured devices."""
         if self._static_config:
             _LOGGER.debug("Adding statically configured WeMo devices")
@@ -248,7 +250,7 @@ async def discover_statics(self):
                     )
 
 
-def validate_static_config(host, port):
+def validate_static_config(host: str, port: int | None) -> pywemo.WeMoDevice | None:
     """Handle a static config."""
     url = pywemo.setup_url_for_address(host, port)
 

homeassistant/components/wemo/binary_sensor.py

@@ -4,16 +4,24 @@
 from pywemo import Insight, Maker
 
 from homeassistant.components.binary_sensor import BinarySensorEntity
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
 
 from .const import DOMAIN as WEMO_DOMAIN
 from .entity import WemoEntity
+from .wemo_device import DeviceCoordinator
 
 
-async def async_setup_entry(hass, config_entry, async_add_entities):
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: ConfigEntry,
+    async_add_entities: AddEntitiesCallback,
+) -> None:
     """Set up WeMo binary sensors."""
 
-    async def _discovered_wemo(coordinator):
+    async def _discovered_wemo(coordinator: DeviceCoordinator) -> None:
         """Handle a discovered Wemo device."""
         if isinstance(coordinator.wemo, Insight):
             async_add_entities([InsightBinarySensor(coordinator)])
@@ -38,7 +46,7 @@ class WemoBinarySensor(WemoEntity, BinarySensorEntity):
     @property
     def is_on(self) -> bool:
         """Return true if the state is on. Standby is on."""
-        return self.wemo.get_state()
+        return bool(self.wemo.get_state())
 
 
 class MakerBinarySensor(WemoEntity, BinarySensorEntity):
@@ -49,7 +57,7 @@ class MakerBinarySensor(WemoEntity, BinarySensorEntity):
     @property
     def is_on(self) -> bool:
         """Return true if the Maker's sensor is pulled low."""
-        return self.wemo.has_sensor and self.wemo.sensor_state == 0
+        return bool(self.wemo.has_sensor) and self.wemo.sensor_state == 0
 
 
 class InsightBinarySensor(WemoBinarySensor):

homeassistant/components/wemo/config_flow.py

@@ -2,12 +2,13 @@
 
 import pywemo
 
+from homeassistant.core import HomeAssistant
 from homeassistant.helpers import config_entry_flow
 
 from . import DOMAIN
 
 
-async def _async_has_devices(hass):
+async def _async_has_devices(hass: HomeAssistant) -> bool:
     """Return if there are devices that can be discovered."""
     return bool(await hass.async_add_executor_job(pywemo.discover_devices))
 

homeassistant/components/wemo/device_trigger.py

@@ -1,10 +1,20 @@
 """Triggers for WeMo devices."""
+from __future__ import annotations
+
+from typing import Any
+
 from pywemo.subscribe import EVENT_TYPE_LONG_PRESS
 import voluptuous as vol
 
+from homeassistant.components.automation import (
+    AutomationActionType,
+    AutomationTriggerInfo,
+)
 from homeassistant.components.device_automation import DEVICE_TRIGGER_BASE_SCHEMA
 from homeassistant.components.homeassistant.triggers import event as event_trigger
 from homeassistant.const import CONF_DEVICE_ID, CONF_DOMAIN, CONF_PLATFORM, CONF_TYPE
+from homeassistant.core import CALLBACK_TYPE, HomeAssistant
+from homeassistant.helpers.typing import ConfigType
 
 from .const import DOMAIN as WEMO_DOMAIN, WEMO_SUBSCRIPTION_EVENT
 from .wemo_device import async_get_coordinator
@@ -18,7 +28,9 @@
 )
 
 
-async def async_get_triggers(hass, device_id):
+async def async_get_triggers(
+    hass: HomeAssistant, device_id: str
+) -> list[dict[str, Any]]:
     """Return a list of triggers."""
 
     wemo_trigger = {
@@ -44,7 +56,12 @@ async def async_get_triggers(hass, device_id):
     return triggers
 
 
-async def async_attach_trigger(hass, config, action, automation_info):
+async def async_attach_trigger(
+    hass: HomeAssistant,
+    config: ConfigType,
+    action: AutomationActionType,
+    automation_info: AutomationTriggerInfo,
+) -> CALLBACK_TYPE:
     """Attach a trigger."""
     event_config = event_trigger.TRIGGER_SCHEMA(
         {

homeassistant/components/wemo/entity.py

@@ -33,7 +33,7 @@ def __init__(self, coordinator: DeviceCoordinator) -> None:
         self._available = True
 
     @property
-    def name_suffix(self):
+    def name_suffix(self) -> str | None:
         """Suffix to append to the WeMo device name."""
         return self._name_suffix
 
@@ -42,26 +42,26 @@ def name(self) -> str:
         """Return the name of the device if any."""
         if suffix := self.name_suffix:
             return f"{self.wemo.name} {suffix}"
-        return self.wemo.name
+        return str(self.wemo.name)
 
     @property
     def available(self) -> bool:
         """Return true if the device is available."""
         return super().available and self._available
 
     @property
-    def unique_id_suffix(self):
+    def unique_id_suffix(self) -> str | None:
         """Suffix to append to the WeMo device's unique ID."""
         if self._unique_id_suffix is None and self.name_suffix is not None:
-            return self._name_suffix.lower()
+            return self.name_suffix.lower()
         return self._unique_id_suffix
 
     @property
     def unique_id(self) -> str:
         """Return the id of this WeMo device."""
         if suffix := self.unique_id_suffix:
             return f"{self.wemo.serialnumber}_{suffix}"
-        return self.wemo.serialnumber
+        return str(self.wemo.serialnumber)
 
     @property
     def device_info(self) -> DeviceInfo:

homeassistant/components/wemo/fan.py

@@ -1,14 +1,19 @@
 """Support for WeMo humidifier."""
+from __future__ import annotations
+
 import asyncio
 from datetime import timedelta
 import math
+from typing import Any
 
 import voluptuous as vol
 
 from homeassistant.components.fan import SUPPORT_SET_SPEED, FanEntity
-from homeassistant.core import callback
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers import entity_platform
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.util.percentage import (
     int_states_in_range,
     percentage_to_ranged_value,
@@ -21,6 +26,7 @@
     SERVICE_SET_HUMIDITY,
 )
 from .entity import WemoEntity
+from .wemo_device import DeviceCoordinator
 
 SCAN_INTERVAL = timedelta(seconds=10)
 PARALLEL_UPDATES = 0
@@ -63,10 +69,14 @@
 }
 
 
-async def async_setup_entry(hass, config_entry, async_add_entities):
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: ConfigEntry,
+    async_add_entities: AddEntitiesCallback,
+) -> None:
     """Set up WeMo binary sensors."""
 
-    async def _discovered_wemo(coordinator):
+    async def _discovered_wemo(coordinator: DeviceCoordinator) -> None:
         """Handle a discovered Wemo device."""
         async_add_entities([WemoHumidifier(coordinator)])
 
@@ -95,7 +105,7 @@ async def _discovered_wemo(coordinator):
 class WemoHumidifier(WemoEntity, FanEntity):
     """Representation of a WeMo humidifier."""
 
-    def __init__(self, coordinator):
+    def __init__(self, coordinator: DeviceCoordinator) -> None:
         """Initialize the WeMo switch."""
         super().__init__(coordinator)
         if self.wemo.fan_mode != WEMO_FAN_OFF:
@@ -104,12 +114,12 @@ def __init__(self, coordinator):
             self._last_fan_on_mode = WEMO_FAN_MEDIUM
 
     @property
-    def icon(self):
+    def icon(self) -> str:
         """Return the icon of device based on its type."""
         return "mdi:water-percent"
 
     @property
-    def extra_state_attributes(self):
+    def extra_state_attributes(self) -> dict[str, Any]:
         """Return device specific state attributes."""
         return {
             ATTR_CURRENT_HUMIDITY: self.wemo.current_humidity_percent,
@@ -145,26 +155,26 @@ def _handle_coordinator_update(self) -> None:
     @property
     def is_on(self) -> bool:
         """Return true if the state is on."""
-        return self.wemo.get_state()
+        return bool(self.wemo.get_state())
 
     def turn_on(
         self,
-        speed: str = None,
-        percentage: int = None,
-        preset_mode: str = None,
-        **kwargs,
+        speed: str | None = None,
+        percentage: int | None = None,
+        preset_mode: str | None = None,
+        **kwargs: Any,
     ) -> None:
         """Turn the fan on."""
         self.set_percentage(percentage)
 
-    def turn_off(self, **kwargs) -> None:
+    def turn_off(self, **kwargs: Any) -> None:
         """Turn the switch off."""
         with self._wemo_exception_handler("turn off"):
             self.wemo.set_state(WEMO_FAN_OFF)
 
         self.schedule_update_ha_state()
 
-    def set_percentage(self, percentage: int) -> None:
+    def set_percentage(self, percentage: int | None) -> None:
         """Set the fan_mode of the Humidifier."""
         if percentage is None:
             named_speed = self._last_fan_on_mode