homeassistant 2025.6.3__py3-none-any.whl → 2025.7.0b0__py3-none-any.whl

homeassistant/components/switchbot/translations/zh-Hant.json

@@ -135,6 +135,22 @@
             }
         },
         "humidifier": {
+            "evaporative_humidifier": {
+                "state_attributes": {
+                    "mode": {
+                        "state": {
+                            "auto": "\u81ea\u52d5",
+                            "drying_filter": "\u4e7e\u71e5\u904e\u6ffe\u5668",
+                            "high": "\u9ad8",
+                            "low": "\u4f4e",
+                            "medium": "\u4e2d",
+                            "quiet": "\u975c\u97f3",
+                            "sleep": "\u7761\u7720",
+                            "target_humidity": "\u76ee\u6a19\u6fd5\u5ea6"
+                        }
+                    }
+                }
+            },
             "humidifier": {
                 "state_attributes": {
                     "last_run_success": {
@@ -146,6 +162,35 @@
                 }
             }
         },
+        "light": {
+            "light": {
+                "state_attributes": {
+                    "effect": {
+                        "state": {
+                            "autumn": "\u79cb\u5929",
+                            "breathing": "\u547c\u5438",
+                            "christmas": "\u8056\u8a95\u7bc0",
+                            "colorful": "\u8c50\u5bcc\u591a\u5f69",
+                            "cool": "\u51b7\u8abf",
+                            "fade": "\u6de1\u51fa",
+                            "flashing": "\u9583\u720d",
+                            "flickering": "\u9583\u52d5",
+                            "flow": "\u6d41\u52d5",
+                            "forest": "\u68ee\u6797",
+                            "halloween": "\u842c\u8056\u7bc0",
+                            "modern": "\u73fe\u4ee3",
+                            "ocean": "\u6d77\u6d0b",
+                            "relax": "\u653e\u9b06",
+                            "rose": "\u73ab\u7470",
+                            "smooth": "\u5e73\u9806",
+                            "strobe": "\u9583\u5149",
+                            "sunset": "\u65e5\u843d",
+                            "vitality": "\u6d3b\u529b"
+                        }
+                    }
+                }
+            }
+        },
         "lock": {
             "lock": {
                 "state_attributes": {
@@ -174,6 +219,15 @@
             "light_level": {
                 "name": "\u5149\u7dda\u7b49\u7d1a"
             },
+            "water_level": {
+                "name": "\u6c34\u4f4d",
+                "state": {
+                    "empty": "\u8017\u76e1",
+                    "high": "\u9ad8",
+                    "low": "\u4f4e",
+                    "medium": "\u4e2d"
+                }
+            },
             "wifi_signal": {
                 "name": "Wi-Fi \u8a0a\u865f"
             }

homeassistant/components/switchbot_cloud/manifest.json

@@ -8,5 +8,5 @@
   "integration_type": "hub",
   "iot_class": "cloud_polling",
   "loggers": ["switchbot_api"],
-  "requirements": ["switchbot-api==2.4.0"]
+  "requirements": ["switchbot-api==2.5.0"]
 }

homeassistant/components/synology_dsm/__init__.py

@@ -12,7 +12,8 @@ from synology_dsm.exceptions import SynologyDSMNotLoggedInException
 from homeassistant.const import CONF_MAC, CONF_SCAN_INTERVAL, CONF_VERIFY_SSL
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
-from homeassistant.helpers import device_registry as dr
+from homeassistant.helpers import config_validation as cv, device_registry as dr
+from homeassistant.helpers.typing import ConfigType
 
 from .common import SynoApi, raise_config_entry_auth_error
 from .const import (
@@ -34,10 +35,20 @@ from .coordinator import (
     SynologyDSMData,
     SynologyDSMSwitchUpdateCoordinator,
 )
-from .service import async_setup_services
+from .services import async_setup_services
 
 _LOGGER = logging.getLogger(__name__)
 
+CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
+
+
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up the Synology DSM component."""
+
+    async_setup_services(hass)
+
+    return True
+
 
 async def async_setup_entry(hass: HomeAssistant, entry: SynologyDSMConfigEntry) -> bool:
     """Set up Synology DSM sensors."""
@@ -89,9 +100,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: SynologyDSMConfigEntry)
             details = EXCEPTION_UNKNOWN
         raise ConfigEntryNotReady(details) from err
 
-    # Services
-    await async_setup_services(hass)
-
     # For SSDP compat
     if not entry.data.get(CONF_MAC):
         hass.config_entries.async_update_entry(

homeassistant/components/synology_dsm/services.py

@@ -0,0 +1,77 @@
+"""The Synology DSM component."""
+
+from __future__ import annotations
+
+import logging
+from typing import cast
+
+from synology_dsm.exceptions import SynologyDSMException
+
+from homeassistant.core import HomeAssistant, ServiceCall, callback
+
+from .const import CONF_SERIAL, DOMAIN, SERVICE_REBOOT, SERVICE_SHUTDOWN, SERVICES
+from .coordinator import SynologyDSMConfigEntry
+
+LOGGER = logging.getLogger(__name__)
+
+
+async def _service_handler(call: ServiceCall) -> None:
+    """Handle service call."""
+    serial: str | None = call.data.get(CONF_SERIAL)
+    entries: list[SynologyDSMConfigEntry] = (
+        call.hass.config_entries.async_loaded_entries(DOMAIN)
+    )
+    dsm_devices = {cast(str, entry.unique_id): entry.runtime_data for entry in entries}
+
+    if serial:
+        entry: SynologyDSMConfigEntry | None = (
+            call.hass.config_entries.async_entry_for_domain_unique_id(DOMAIN, serial)
+        )
+        assert entry
+        dsm_device = entry.runtime_data
+    elif len(dsm_devices) == 1:
+        dsm_device = next(iter(dsm_devices.values()))
+        serial = next(iter(dsm_devices))
+    else:
+        LOGGER.error(
+            "More than one DSM configured, must specify one of serials %s",
+            sorted(dsm_devices),
+        )
+        return
+
+    if not dsm_device:
+        LOGGER.error("DSM with specified serial %s not found", serial)
+        return
+
+    if call.service in [SERVICE_REBOOT, SERVICE_SHUTDOWN]:
+        if serial not in dsm_devices:
+            LOGGER.error("DSM with specified serial %s not found", serial)
+            return
+        LOGGER.debug("%s DSM with serial %s", call.service, serial)
+        LOGGER.warning(
+            (
+                "The %s service is deprecated and will be removed in future"
+                " release. Please use the corresponding button entity"
+            ),
+            call.service,
+        )
+        dsm_device = dsm_devices[serial]
+        dsm_api = dsm_device.api
+        try:
+            await getattr(dsm_api, f"async_{call.service}")()
+        except SynologyDSMException as ex:
+            LOGGER.error(
+                "%s of DSM with serial %s not possible, because of %s",
+                call.service,
+                serial,
+                ex,
+            )
+            return
+
+
+@callback
+def async_setup_services(hass: HomeAssistant) -> None:
+    """Service handler setup."""
+
+    for service in SERVICES:
+        hass.services.async_register(DOMAIN, service, _service_handler)

homeassistant/components/system_health/__init__.py

@@ -231,7 +231,7 @@ async def handle_info(
                     "Error fetching system info for %s - %s",
                     domain,
                     key,
-                    exc_info=(type(exception), exception, exception.__traceback__),
+                    exc_info=(type(exception), exception, exception.__traceback__),  # noqa: LOG014
                 )
                 event_msg["success"] = False
                 event_msg["error"] = {"type": "failed", "error": "unknown"}

homeassistant/components/tado/__init__.py

@@ -35,7 +35,7 @@ from .const import (
 )
 from .coordinator import TadoDataUpdateCoordinator, TadoMobileDeviceUpdateCoordinator
 from .models import TadoData
-from .services import setup_services
+from .services import async_setup_services
 
 PLATFORMS = [
     Platform.BINARY_SENSOR,
@@ -58,7 +58,7 @@ _LOGGER = logging.getLogger(__name__)
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up Tado."""
 
-    setup_services(hass)
+    async_setup_services(hass)
     return True
 
 

homeassistant/components/tado/services.py

@@ -29,26 +29,27 @@ SCHEMA_ADD_METER_READING = vol.Schema(
 )
 
 
-@callback
-def setup_services(hass: HomeAssistant) -> None:
-    """Set up the services for the Tado integration."""
+async def _add_meter_reading(call: ServiceCall) -> None:
+    """Send meter reading to Tado."""
+    entry_id: str = call.data[CONF_CONFIG_ENTRY]
+    reading: int = call.data[CONF_READING]
+    _LOGGER.debug("Add meter reading %s", reading)
+
+    entry = call.hass.config_entries.async_get_entry(entry_id)
+    if entry is None:
+        raise ServiceValidationError("Config entry not found")
 
-    async def add_meter_reading(call: ServiceCall) -> None:
-        """Send meter reading to Tado."""
-        entry_id: str = call.data[CONF_CONFIG_ENTRY]
-        reading: int = call.data[CONF_READING]
-        _LOGGER.debug("Add meter reading %s", reading)
+    coordinator = entry.runtime_data.coordinator
+    response: dict = await coordinator.set_meter_reading(call.data[CONF_READING])
 
-        entry = hass.config_entries.async_get_entry(entry_id)
-        if entry is None:
-            raise ServiceValidationError("Config entry not found")
+    if ATTR_MESSAGE in response:
+        raise HomeAssistantError(response[ATTR_MESSAGE])
 
-        coordinator = entry.runtime_data.coordinator
-        response: dict = await coordinator.set_meter_reading(call.data[CONF_READING])
 
-        if ATTR_MESSAGE in response:
-            raise HomeAssistantError(response[ATTR_MESSAGE])
+@callback
+def async_setup_services(hass: HomeAssistant) -> None:
+    """Set up the services for the Tado integration."""
 
     hass.services.async_register(
-        DOMAIN, SERVICE_ADD_METER_READING, add_meter_reading, SCHEMA_ADD_METER_READING
+        DOMAIN, SERVICE_ADD_METER_READING, _add_meter_reading, SCHEMA_ADD_METER_READING
     )

homeassistant/components/tailscale/translations/nl.json

@@ -25,6 +25,11 @@
         }
     },
     "entity": {
+        "binary_sensor": {
+            "client_supports_ipv6": {
+                "name": "Ondersteunt IPv6"
+            }
+        },
         "sensor": {
             "ip": {
                 "name": "IP-adres"

homeassistant/components/tedee/binary_sensor.py

@@ -4,7 +4,7 @@ from collections.abc import Callable
 from dataclasses import dataclass
 
 from aiotedee import TedeeLock
-from aiotedee.lock import TedeeLockState
+from aiotedee.lock import TedeeDoorState, TedeeLockState
 
 from homeassistant.components.binary_sensor import (
     BinarySensorDeviceClass,
@@ -29,6 +29,8 @@ class TedeeBinarySensorEntityDescription(
     """Describes Tedee binary sensor entity."""
 
     is_on_fn: Callable[[TedeeLock], bool | None]
+    supported_fn: Callable[[TedeeLock], bool] = lambda _: True
+    available_fn: Callable[[TedeeLock], bool] = lambda _: True
 
 
 ENTITIES: tuple[TedeeBinarySensorEntityDescription, ...] = (
@@ -61,6 +63,14 @@ ENTITIES: tuple[TedeeBinarySensorEntityDescription, ...] = (
         entity_category=EntityCategory.DIAGNOSTIC,
         entity_registry_enabled_default=False,
     ),
+    TedeeBinarySensorEntityDescription(
+        key="door_state",
+        is_on_fn=lambda lock: lock.door_state is TedeeDoorState.OPENED,
+        device_class=BinarySensorDeviceClass.DOOR,
+        supported_fn=lambda lock: lock.door_state is not TedeeDoorState.NOT_PAIRED,
+        available_fn=lambda lock: lock.door_state
+        not in [TedeeDoorState.UNCALIBRATED, TedeeDoorState.DISCONNECTED],
+    ),
 )
 
 
@@ -77,6 +87,7 @@ async def async_setup_entry(
             TedeeBinarySensorEntity(lock, coordinator, entity_description)
             for entity_description in ENTITIES
             for lock in locks
+            if entity_description.supported_fn(lock)
         )
 
     coordinator.new_lock_callbacks.append(_async_add_new_lock)
@@ -92,3 +103,8 @@ class TedeeBinarySensorEntity(TedeeDescriptionEntity, BinarySensorEntity):
     def is_on(self) -> bool | None:
         """Return true if the binary sensor is on."""
         return self.entity_description.is_on_fn(self._lock)
+
+    @property
+    def available(self) -> bool:
+        """Return true if the binary sensor is available."""
+        return self.entity_description.available_fn(self._lock) and super().available

homeassistant/components/tedee/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "local_push",
   "loggers": ["aiotedee"],
   "quality_scale": "platinum",
-  "requirements": ["aiotedee==0.2.23"]
+  "requirements": ["aiotedee==0.2.25"]
 }