homeassistant 2025.9.4__py3-none-any.whl → 2025.10.0b0__py3-none-any.whl

homeassistant/components/vesync/__init__.py

@@ -3,29 +3,17 @@
 import logging
 
 from pyvesync import VeSync
+from pyvesync.utils.errors import VeSyncLoginError
 
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import (
-    CONF_PASSWORD,
-    CONF_USERNAME,
-    EVENT_LOGGING_CHANGED,
-    Platform,
-)
-from homeassistant.core import Event, HomeAssistant, ServiceCall, callback
+from homeassistant.const import CONF_PASSWORD, CONF_USERNAME, Platform
+from homeassistant.core import HomeAssistant, ServiceCall
 from homeassistant.exceptions import ConfigEntryAuthFailed
 from homeassistant.helpers import entity_registry as er
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.dispatcher import async_dispatcher_send
 
-from .common import async_generate_device_list
-from .const import (
-    DOMAIN,
-    SERVICE_UPDATE_DEVS,
-    VS_COORDINATOR,
-    VS_DEVICES,
-    VS_DISCOVERY,
-    VS_LISTENERS,
-    VS_MANAGER,
-)
+from .const import DOMAIN, SERVICE_UPDATE_DEVS, VS_COORDINATOR, VS_MANAGER
 from .coordinator import VeSyncDataCoordinator
 
 PLATFORMS = [
@@ -53,14 +41,12 @@ async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry) -> b
         username=username,
         password=password,
         time_zone=time_zone,
-        debug=logging.getLogger("pyvesync.vesync").level == logging.DEBUG,
-        redact=True,
+        session=async_get_clientsession(hass),
     )
-
-    login = await hass.async_add_executor_job(manager.login)
-
-    if not login:
-        raise ConfigEntryAuthFailed
+    try:
+        await manager.login()
+    except VeSyncLoginError as err:
+        raise ConfigEntryAuthFailed from err
 
     hass.data[DOMAIN] = {}
     hass.data[DOMAIN][VS_MANAGER] = manager
@@ -69,37 +55,22 @@ async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry) -> b
 
     # Store coordinator at domain level since only single integration instance is permitted.
     hass.data[DOMAIN][VS_COORDINATOR] = coordinator
-
-    hass.data[DOMAIN][VS_DEVICES] = await async_generate_device_list(hass, manager)
+    await manager.update()
+    await manager.check_firmware()
 
     await hass.config_entries.async_forward_entry_setups(config_entry, PLATFORMS)
 
-    @callback
-    def _async_handle_logging_changed(_event: Event) -> None:
-        """Handle when the logging level changes."""
-        manager.debug = logging.getLogger("pyvesync.vesync").level == logging.DEBUG
-
-    cleanup = hass.bus.async_listen(
-        EVENT_LOGGING_CHANGED, _async_handle_logging_changed
-    )
-
-    hass.data[DOMAIN][VS_LISTENERS] = cleanup
-
     async def async_new_device_discovery(service: ServiceCall) -> None:
-        """Discover if new devices should be added."""
+        """Discover and add new devices."""
         manager = hass.data[DOMAIN][VS_MANAGER]
-        devices = hass.data[DOMAIN][VS_DEVICES]
-
-        new_devices = await async_generate_device_list(hass, manager)
+        known_devices = list(manager.devices)
+        await manager.get_devices()
+        new_devices = [
+            device for device in manager.devices if device not in known_devices
+        ]
 
-        device_set = set(new_devices)
-        new_devices = list(device_set.difference(devices))
-        if new_devices and devices:
-            devices.extend(new_devices)
-            async_dispatcher_send(hass, VS_DISCOVERY.format(VS_DEVICES), new_devices)
-            return
-        if new_devices and not devices:
-            devices.extend(new_devices)
+        if new_devices:
+            async_dispatcher_send(hass, "vesync_new_devices", new_devices)
 
     hass.services.async_register(
         DOMAIN, SERVICE_UPDATE_DEVS, async_new_device_discovery
@@ -110,7 +81,6 @@ async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry) -> b
 
 async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Unload a config entry."""
-    hass.data[DOMAIN][VS_LISTENERS]()
     unload_ok = await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
     if unload_ok:
         hass.data.pop(DOMAIN)

homeassistant/components/vesync/binary_sensor.py

@@ -6,7 +6,7 @@ from collections.abc import Callable
 from dataclasses import dataclass
 import logging
 
-from pyvesync.vesyncbasedevice import VeSyncBaseDevice
+from pyvesync.base_devices.vesyncbasedevice import VeSyncBaseDevice
 
 from homeassistant.components.binary_sensor import (
     BinarySensorDeviceClass,
@@ -19,7 +19,7 @@ from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from .common import rgetattr
-from .const import DOMAIN, VS_COORDINATOR, VS_DEVICES, VS_DISCOVERY
+from .const import DOMAIN, VS_COORDINATOR, VS_DEVICES, VS_DISCOVERY, VS_MANAGER
 from .coordinator import VeSyncDataCoordinator
 from .entity import VeSyncBaseEntity
 
@@ -31,20 +31,25 @@ class VeSyncBinarySensorEntityDescription(BinarySensorEntityDescription):
     """A class that describes custom binary sensor entities."""
 
     is_on: Callable[[VeSyncBaseDevice], bool]
+    exists_fn: Callable[[VeSyncBaseDevice], bool] = lambda _: True
 
 
 SENSOR_DESCRIPTIONS: tuple[VeSyncBinarySensorEntityDescription, ...] = (
     VeSyncBinarySensorEntityDescription(
         key="water_lacks",
         translation_key="water_lacks",
-        is_on=lambda device: device.water_lacks,
+        is_on=lambda device: device.state.water_lacks,
         device_class=BinarySensorDeviceClass.PROBLEM,
+        exists_fn=lambda device: rgetattr(device, "state.water_lacks") is not None,
     ),
     VeSyncBinarySensorEntityDescription(
-        key="details.water_tank_lifted",
+        key="water_tank_lifted",
         translation_key="water_tank_lifted",
-        is_on=lambda device: device.details["water_tank_lifted"],
+        is_on=lambda device: device.state.water_tank_lifted,
         device_class=BinarySensorDeviceClass.PROBLEM,
+        exists_fn=(
+            lambda device: rgetattr(device, "state.water_tank_lifted") is not None
+        ),
     ),
 )
 
@@ -67,7 +72,9 @@ async def async_setup_entry(
         async_dispatcher_connect(hass, VS_DISCOVERY.format(VS_DEVICES), discover)
     )
 
-    _setup_entities(hass.data[DOMAIN][VS_DEVICES], async_add_entities, coordinator)
+    _setup_entities(
+        hass.data[DOMAIN][VS_MANAGER].devices, async_add_entities, coordinator
+    )
 
 
 @callback
@@ -78,7 +85,7 @@ def _setup_entities(devices, async_add_entities, coordinator):
             VeSyncBinarySensor(dev, description, coordinator)
             for dev in devices
             for description in SENSOR_DESCRIPTIONS
-            if rgetattr(dev, description.key) is not None
+            if description.exists_fn(dev)
         ),
     )
 

homeassistant/components/vesync/common.py

@@ -2,14 +2,12 @@
 
 import logging
 
-from pyvesync import VeSync
-from pyvesync.vesyncbasedevice import VeSyncBaseDevice
-from pyvesync.vesyncoutlet import VeSyncOutlet
-from pyvesync.vesyncswitch import VeSyncWallSwitch
-
-from homeassistant.core import HomeAssistant
-
-from .const import VeSyncFanDevice, VeSyncHumidifierDevice
+from pyvesync.base_devices import VeSyncHumidifier
+from pyvesync.base_devices.fan_base import VeSyncFanBase
+from pyvesync.base_devices.outlet_base import VeSyncOutlet
+from pyvesync.base_devices.purifier_base import VeSyncPurifier
+from pyvesync.base_devices.vesyncbasedevice import VeSyncBaseDevice
+from pyvesync.devices.vesyncswitch import VeSyncWallSwitch
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -36,32 +34,16 @@ def rgetattr(obj: object, attr: str):
     return obj
 
 
-async def async_generate_device_list(
-    hass: HomeAssistant, manager: VeSync
-) -> list[VeSyncBaseDevice]:
-    """Assign devices to proper component."""
-    devices: list[VeSyncBaseDevice] = []
-
-    await hass.async_add_executor_job(manager.update)
-
-    devices.extend(manager.fans)
-    devices.extend(manager.bulbs)
-    devices.extend(manager.outlets)
-    devices.extend(manager.switches)
-
-    return devices
-
-
 def is_humidifier(device: VeSyncBaseDevice) -> bool:
     """Check if the device represents a humidifier."""
 
-    return isinstance(device, VeSyncHumidifierDevice)
+    return isinstance(device, VeSyncHumidifier)
 
 
 def is_fan(device: VeSyncBaseDevice) -> bool:
     """Check if the device represents a fan."""
 
-    return isinstance(device, VeSyncFanDevice)
+    return isinstance(device, VeSyncFanBase)
 
 
 def is_outlet(device: VeSyncBaseDevice) -> bool:
@@ -74,3 +56,9 @@ def is_wall_switch(device: VeSyncBaseDevice) -> bool:
     """Check if the device represents a wall switch, note this doessn't include dimming switches."""
 
     return isinstance(device, VeSyncWallSwitch)
+
+
+def is_purifier(device: VeSyncBaseDevice) -> bool:
+    """Check if the device represents an air purifier."""
+
+    return isinstance(device, VeSyncPurifier)

homeassistant/components/vesync/config_flow.py

@@ -1,18 +1,23 @@
 """Config flow utilities."""
 
 from collections.abc import Mapping
+import logging
 from typing import Any
 
 from pyvesync import VeSync
+from pyvesync.utils.errors import VeSyncError
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
 from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
 from homeassistant.core import callback
 from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
 
 from .const import DOMAIN
 
+_LOGGER = logging.getLogger(__name__)
+
 DATA_SCHEMA = vol.Schema(
     {
         vol.Required(CONF_USERNAME): cv.string,
@@ -49,9 +54,18 @@ class VeSyncFlowHandler(ConfigFlow, domain=DOMAIN):
         username = user_input[CONF_USERNAME]
         password = user_input[CONF_PASSWORD]
 
-        manager = VeSync(username, password)
-        login = await self.hass.async_add_executor_job(manager.login)
-        if not login:
+        time_zone = str(self.hass.config.time_zone)
+
+        manager = VeSync(
+            username,
+            password,
+            time_zone=time_zone,
+            session=async_get_clientsession(self.hass),
+        )
+        try:
+            await manager.login()
+        except VeSyncError as e:
+            _LOGGER.error("VeSync login failed: %s", str(e))
             return self._show_form(errors={"base": "invalid_auth"})
 
         return self.async_create_entry(
@@ -74,17 +88,33 @@ class VeSyncFlowHandler(ConfigFlow, domain=DOMAIN):
             username = user_input[CONF_USERNAME]
             password = user_input[CONF_PASSWORD]
 
-            manager = VeSync(username, password)
-            login = await self.hass.async_add_executor_job(manager.login)
-            if login:
-                return self.async_update_reload_and_abort(
-                    self._get_reauth_entry(),
-                    data_updates={
-                        CONF_USERNAME: username,
-                        CONF_PASSWORD: password,
-                    },
+            time_zone = str(self.hass.config.time_zone)
+
+            manager = VeSync(
+                username,
+                password,
+                time_zone=time_zone,
+                session=async_get_clientsession(self.hass),
+            )
+            try:
+                await manager.login()
+            except VeSyncError as e:
+                _LOGGER.error("VeSync login failed: %s", str(e))
+                return self.async_show_form(
+                    step_id="reauth_confirm",
+                    data_schema=DATA_SCHEMA,
+                    description_placeholders={"name": "VeSync"},
+                    errors={"base": "invalid_auth"},
                 )
 
+            return self.async_update_reload_and_abort(
+                self._get_reauth_entry(),
+                data_updates={
+                    CONF_USERNAME: username,
+                    CONF_PASSWORD: password,
+                },
+            )
+
         return self.async_show_form(
             step_id="reauth_confirm",
             data_schema=DATA_SCHEMA,

homeassistant/components/vesync/const.py

@@ -1,18 +1,11 @@
 """Constants for VeSync Component."""
 
-from pyvesync.vesyncfan import (
-    VeSyncAir131,
-    VeSyncAirBaseV2,
-    VeSyncAirBypass,
-    VeSyncHumid200300S,
-    VeSyncSuperior6000S,
-)
-
 DOMAIN = "vesync"
 VS_DISCOVERY = "vesync_discovery_{}"
 SERVICE_UPDATE_DEVS = "update_devices"
 
 UPDATE_INTERVAL = 60
+UPDATE_INTERVAL_ENERGY = 60 * 60 * 6
 """
 Update interval for DataCoordinator.
 
@@ -24,6 +17,9 @@ total would be 2880.
 
 Using 30 seconds interval gives 8640 for 3 devices which
 exceeds the quota of 7700.
+
+Energy history is weekly/monthly/yearly and can be updated a lot more infrequently,
+in this case every 6 hours.
 """
 VS_DEVICES = "devices"
 VS_COORDINATOR = "coordinator"
@@ -57,87 +53,14 @@ NIGHT_LIGHT_LEVEL_BRIGHT = "bright"
 NIGHT_LIGHT_LEVEL_DIM = "dim"
 NIGHT_LIGHT_LEVEL_OFF = "off"
 
-FAN_NIGHT_LIGHT_LEVEL_DIM = "dim"
-FAN_NIGHT_LIGHT_LEVEL_OFF = "off"
-FAN_NIGHT_LIGHT_LEVEL_ON = "on"
-
 HUMIDIFIER_NIGHT_LIGHT_LEVEL_BRIGHT = "bright"
 HUMIDIFIER_NIGHT_LIGHT_LEVEL_DIM = "dim"
 HUMIDIFIER_NIGHT_LIGHT_LEVEL_OFF = "off"
 
-VeSyncHumidifierDevice = VeSyncHumid200300S | VeSyncSuperior6000S
-"""Humidifier device types"""
-
-VeSyncFanDevice = VeSyncAirBypass | VeSyncAirBypass | VeSyncAirBaseV2 | VeSyncAir131
-"""Fan device types"""
-
-
-DEV_TYPE_TO_HA = {
-    "wifi-switch-1.3": "outlet",
-    "ESW03-USA": "outlet",
-    "ESW01-EU": "outlet",
-    "ESW15-USA": "outlet",
-    "ESWL01": "switch",
-    "ESWL03": "switch",
-    "ESO15-TB": "outlet",
-    "LV-PUR131S": "fan",
-    "Core200S": "fan",
-    "Core300S": "fan",
-    "Core400S": "fan",
-    "Core600S": "fan",
-    "EverestAir": "fan",
-    "Vital200S": "fan",
-    "Vital100S": "fan",
-    "SmartTowerFan": "fan",
-    "ESD16": "walldimmer",
-    "ESWD16": "walldimmer",
-    "ESL100": "bulb-dimmable",
-    "ESL100CW": "bulb-tunable-white",
-}
+OUTLET_NIGHT_LIGHT_LEVEL_AUTO = "auto"
+OUTLET_NIGHT_LIGHT_LEVEL_OFF = "off"
+OUTLET_NIGHT_LIGHT_LEVEL_ON = "on"
 
-SKU_TO_BASE_DEVICE = {
-    # Air Purifiers
-    "LV-PUR131S": "LV-PUR131S",
-    "LV-RH131S": "LV-PUR131S",  # Alt ID Model LV-PUR131S
-    "LV-RH131S-WM": "LV-PUR131S",  # Alt ID Model LV-PUR131S
-    "Core200S": "Core200S",
-    "LAP-C201S-AUSR": "Core200S",  # Alt ID Model Core200S
-    "LAP-C202S-WUSR": "Core200S",  # Alt ID Model Core200S
-    "Core300S": "Core300S",
-    "LAP-C301S-WJP": "Core300S",  # Alt ID Model Core300S
-    "LAP-C301S-WAAA": "Core300S",  # Alt ID Model Core300S
-    "LAP-C302S-WUSB": "Core300S",  # Alt ID Model Core300S
-    "Core400S": "Core400S",
-    "LAP-C401S-WJP": "Core400S",  # Alt ID Model Core400S
-    "LAP-C401S-WUSR": "Core400S",  # Alt ID Model Core400S
-    "LAP-C401S-WAAA": "Core400S",  # Alt ID Model Core400S
-    "Core600S": "Core600S",
-    "LAP-C601S-WUS": "Core600S",  # Alt ID Model Core600S
-    "LAP-C601S-WUSR": "Core600S",  # Alt ID Model Core600S
-    "LAP-C601S-WEU": "Core600S",  # Alt ID Model Core600S,
-    "Vital200S": "Vital200S",
-    "LAP-V201S-AASR": "Vital200S",  # Alt ID Model Vital200S
-    "LAP-V201S-WJP": "Vital200S",  # Alt ID Model Vital200S
-    "LAP-V201S-WEU": "Vital200S",  # Alt ID Model Vital200S
-    "LAP-V201S-WUS": "Vital200S",  # Alt ID Model Vital200S
-    "LAP-V201-AUSR": "Vital200S",  # Alt ID Model Vital200S
-    "LAP-V201S-AEUR": "Vital200S",  # Alt ID Model Vital200S
-    "LAP-V201S-AUSR": "Vital200S",  # Alt ID Model Vital200S
-    "Vital100S": "Vital100S",
-    "LAP-V102S-WUS": "Vital100S",  # Alt ID Model Vital100S
-    "LAP-V102S-AASR": "Vital100S",  # Alt ID Model Vital100S
-    "LAP-V102S-WEU": "Vital100S",  # Alt ID Model Vital100S
-    "LAP-V102S-WUK": "Vital100S",  # Alt ID Model Vital100S
-    "LAP-V102S-AUSR": "Vital100S",  # Alt ID Model Vital100S
-    "LAP-V102S-WJP": "Vital100S",  # Alt ID Model Vital100S
-    "EverestAir": "EverestAir",
-    "LAP-EL551S-AUS": "EverestAir",  # Alt ID Model EverestAir
-    "LAP-EL551S-AEUR": "EverestAir",  # Alt ID Model EverestAir
-    "LAP-EL551S-WEU": "EverestAir",  # Alt ID Model EverestAir
-    "LAP-EL551S-WUS": "EverestAir",  # Alt ID Model EverestAir
-    "SmartTowerFan": "SmartTowerFan",
-    "LTF-F422S-KEU": "SmartTowerFan",  # Alt ID Model SmartTowerFan
-    "LTF-F422S-WUSR": "SmartTowerFan",  # Alt ID Model SmartTowerFan
-    "LTF-F422_WJP": "SmartTowerFan",  # Alt ID Model SmartTowerFan
-    "LTF-F422S-WUS": "SmartTowerFan",  # Alt ID Model SmartTowerFan
-}
+PURIFIER_NIGHT_LIGHT_LEVEL_DIM = "dim"
+PURIFIER_NIGHT_LIGHT_LEVEL_OFF = "off"
+PURIFIER_NIGHT_LIGHT_LEVEL_ON = "on"

homeassistant/components/vesync/coordinator.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from datetime import timedelta
+from datetime import datetime, timedelta
 import logging
 
 from pyvesync import VeSync
@@ -11,7 +11,7 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 
-from .const import UPDATE_INTERVAL
+from .const import UPDATE_INTERVAL, UPDATE_INTERVAL_ENERGY
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -20,6 +20,7 @@ class VeSyncDataCoordinator(DataUpdateCoordinator[None]):
     """Class representing data coordinator for VeSync devices."""
 
     config_entry: ConfigEntry
+    update_time: datetime | None = None
 
     def __init__(
         self, hass: HomeAssistant, config_entry: ConfigEntry, manager: VeSync
@@ -35,15 +36,21 @@ class VeSyncDataCoordinator(DataUpdateCoordinator[None]):
             update_interval=timedelta(seconds=UPDATE_INTERVAL),
         )
 
+    def should_update_energy(self) -> bool:
+        """Test if specified update interval has been exceeded."""
+        if self.update_time is None:
+            return True
+
+        return datetime.now() - self.update_time >= timedelta(
+            seconds=UPDATE_INTERVAL_ENERGY
+        )
+
     async def _async_update_data(self) -> None:
         """Fetch data from API endpoint."""
 
-        return await self.hass.async_add_executor_job(self.update_data_all)
-
-    def update_data_all(self) -> None:
-        """Update all the devices."""
+        await self._manager.update_all_devices()
 
-        # Using `update_all_devices` instead of `update` to avoid fetching device list every time.
-        self._manager.update_all_devices()
-        # Vesync updates energy on applicable devices every 6 hours
-        self._manager.update_energy()
+        if self.should_update_energy():
+            self.update_time = datetime.now()
+            for outlet in self._manager.devices.outlets:
+                await outlet.update_energy()

homeassistant/components/vesync/diagnostics.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import Any
+from typing import Any, cast
 
 from pyvesync import VeSync
 
@@ -13,7 +13,6 @@ from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.device_registry import DeviceEntry
 
 from .const import DOMAIN, VS_MANAGER
-from .entity import VeSyncBaseDevice
 
 KEYS_TO_REDACT = {"manager", "uuid", "mac_id"}
 
@@ -26,18 +25,16 @@ async def async_get_config_entry_diagnostics(
 
     return {
         DOMAIN: {
-            "bulb_count": len(manager.bulbs),
-            "fan_count": len(manager.fans),
-            "outlets_count": len(manager.outlets),
-            "switch_count": len(manager.switches),
+            "Total Device Count": len(manager.devices),
+            "bulb_count": len(manager.devices.bulbs),
+            "fan_count": len(manager.devices.fans),
+            "humidifers_count": len(manager.devices.humidifiers),
+            "air_purifiers": len(manager.devices.air_purifiers),
+            "outlets_count": len(manager.devices.outlets),
+            "switch_count": len(manager.devices.switches),
             "timezone": manager.time_zone,
         },
-        "devices": {
-            "bulbs": [_redact_device_values(device) for device in manager.bulbs],
-            "fans": [_redact_device_values(device) for device in manager.fans],
-            "outlets": [_redact_device_values(device) for device in manager.outlets],
-            "switches": [_redact_device_values(device) for device in manager.switches],
-        },
+        "devices": [_redact_device_values(device) for device in manager.devices],
     }
 
 
@@ -46,11 +43,24 @@ async def async_get_device_diagnostics(
 ) -> dict[str, Any]:
     """Return diagnostics for a device entry."""
     manager: VeSync = hass.data[DOMAIN][VS_MANAGER]
-    device_dict = _build_device_dict(manager)
     vesync_device_id = next(iden[1] for iden in device.identifiers if iden[0] == DOMAIN)
 
+    def get_vesync_unique_id(dev: Any) -> str:
+        """Return the unique ID for a VeSync device."""
+        cid = getattr(dev, "cid", None)
+        sub_device_no = getattr(dev, "sub_device_no", None)
+        if cid is None:
+            return ""
+        if isinstance(sub_device_no, int):
+            return f"{cid}{sub_device_no!s}"
+        return str(cid)
+
+    vesync_device = next(
+        dev for dev in manager.devices if get_vesync_unique_id(dev) == vesync_device_id
+    )
+
     # Base device information, without sensitive information.
-    data = _redact_device_values(device_dict[vesync_device_id])
+    data = _redact_device_values(vesync_device)
 
     data["home_assistant"] = {
         "name": device.name,
@@ -76,7 +86,7 @@ async def async_get_device_diagnostics(
             # The context doesn't provide useful information in this case.
             state_dict.pop("context", None)
 
-        data["home_assistant"]["entities"].append(
+        cast(dict[str, Any], data["home_assistant"])["entities"].append(
             {
                 "domain": entity_entry.domain,
                 "entity_id": entity_entry.entity_id,
@@ -97,21 +107,19 @@ async def async_get_device_diagnostics(
     return data
 
 
-def _build_device_dict(manager: VeSync) -> dict:
-    """Build a dictionary of ALL VeSync devices."""
-    device_dict = {x.cid: x for x in manager.switches}
-    device_dict.update({x.cid: x for x in manager.fans})
-    device_dict.update({x.cid: x for x in manager.outlets})
-    device_dict.update({x.cid: x for x in manager.bulbs})
-    return device_dict
-
-
-def _redact_device_values(device: VeSyncBaseDevice) -> dict:
+def _redact_device_values(obj: object) -> dict[str, str | dict[str, Any]]:
     """Rebuild and redact values of a VeSync device."""
-    data = {}
-    for key, item in device.__dict__.items():
-        if key not in KEYS_TO_REDACT:
-            data[key] = item
+    data: dict[str, str | dict[str, Any]] = {}
+    for key in dir(obj):
+        if key.startswith("_"):
+            # Skip private attributes
+            continue
+        if callable(getattr(obj, key)):
+            data[key] = "Method"
+        elif key == "state":
+            data[key] = _redact_device_values(getattr(obj, key))
+        elif key not in KEYS_TO_REDACT:
+            data[key] = getattr(obj, key)
         else:
             data[key] = REDACTED
 

homeassistant/components/vesync/entity.py

@@ -1,6 +1,6 @@
 """Common entity for VeSync Component."""
 
-from pyvesync.vesyncbasedevice import VeSyncBaseDevice
+from pyvesync.base_devices.vesyncbasedevice import VeSyncBaseDevice
 
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
@@ -35,7 +35,7 @@ class VeSyncBaseEntity(CoordinatorEntity[VeSyncDataCoordinator]):
     @property
     def available(self) -> bool:
         """Return True if device is available."""
-        return self.device.connection_status == "online"
+        return self.device.state.connection_status == "online"
 
     @property
     def device_info(self) -> DeviceInfo: