homeassistant 2025.8.3__py3-none-any.whl → 2025.9.0b1__py3-none-any.whl

homeassistant/components/workday/util.py

@@ -0,0 +1,254 @@
+"""Helpers functions for the Workday component."""
+
+from datetime import date, timedelta
+from functools import partial
+from typing import TYPE_CHECKING
+
+from holidays import PUBLIC, DateLike, HolidayBase, country_holidays
+
+from homeassistant.const import CONF_COUNTRY
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryError
+from homeassistant.helpers.issue_registry import IssueSeverity, async_create_issue
+from homeassistant.setup import SetupPhases, async_pause_setup
+from homeassistant.util import dt as dt_util, slugify
+
+if TYPE_CHECKING:
+    from . import WorkdayConfigEntry
+from .const import CONF_REMOVE_HOLIDAYS, DOMAIN, LOGGER
+
+
+async def async_validate_country_and_province(
+    hass: HomeAssistant,
+    entry: "WorkdayConfigEntry",
+    country: str | None,
+    province: str | None,
+) -> None:
+    """Validate country and province."""
+
+    if not country:
+        return
+    try:
+        with async_pause_setup(hass, SetupPhases.WAIT_IMPORT_PACKAGES):
+            # import executor job is used here because multiple integrations use
+            # the holidays library and it is not thread safe to import it in parallel
+            # https://github.com/python/cpython/issues/83065
+            await hass.async_add_import_executor_job(country_holidays, country)
+    except NotImplementedError as ex:
+        async_create_issue(
+            hass,
+            DOMAIN,
+            "bad_country",
+            is_fixable=True,
+            is_persistent=False,
+            severity=IssueSeverity.ERROR,
+            translation_key="bad_country",
+            translation_placeholders={"title": entry.title},
+            data={"entry_id": entry.entry_id, "country": None},
+        )
+        raise ConfigEntryError(f"Selected country {country} is not valid") from ex
+
+    if not province:
+        return
+    try:
+        with async_pause_setup(hass, SetupPhases.WAIT_IMPORT_PACKAGES):
+            # import executor job is used here because multiple integrations use
+            # the holidays library and it is not thread safe to import it in parallel
+            # https://github.com/python/cpython/issues/83065
+            await hass.async_add_import_executor_job(
+                partial(country_holidays, country, subdiv=province)
+            )
+    except NotImplementedError as ex:
+        async_create_issue(
+            hass,
+            DOMAIN,
+            "bad_province",
+            is_fixable=True,
+            is_persistent=False,
+            severity=IssueSeverity.ERROR,
+            translation_key="bad_province",
+            translation_placeholders={
+                CONF_COUNTRY: country,
+                "title": entry.title,
+            },
+            data={"entry_id": entry.entry_id, "country": country},
+        )
+        raise ConfigEntryError(
+            f"Selected province {province} for country {country} is not valid"
+        ) from ex
+
+
+def validate_dates(holiday_list: list[str]) -> list[str]:
+    """Validate and add to list of dates to add or remove."""
+    calc_holidays: list[str] = []
+    for add_date in holiday_list:
+        if add_date.find(",") > 0:
+            dates = add_date.split(",", maxsplit=1)
+            d1 = dt_util.parse_date(dates[0])
+            d2 = dt_util.parse_date(dates[1])
+            if d1 is None or d2 is None:
+                LOGGER.error("Incorrect dates in date range: %s", add_date)
+                continue
+            _range: timedelta = d2 - d1
+            for i in range(_range.days + 1):
+                day: date = d1 + timedelta(days=i)
+                calc_holidays.append(day.strftime("%Y-%m-%d"))
+            continue
+        calc_holidays.append(add_date)
+    return calc_holidays
+
+
+def get_holidays_object(
+    country: str | None,
+    province: str | None,
+    year: int,
+    language: str | None,
+    categories: list[str] | None,
+) -> HolidayBase:
+    """Get the object for the requested country and year."""
+    if not country:
+        return HolidayBase()
+
+    set_categories = None
+    if categories:
+        category_list = [PUBLIC]
+        category_list.extend(categories)
+        set_categories = tuple(category_list)
+
+    obj_holidays: HolidayBase = country_holidays(
+        country,
+        subdiv=province,
+        years=[year, year + 1],
+        language=language,
+        categories=set_categories,
+    )
+
+    supported_languages = obj_holidays.supported_languages
+    default_language = obj_holidays.default_language
+
+    if default_language and not language:
+        # If no language is set, use the default language
+        LOGGER.debug("Changing language from None to %s", default_language)
+        return country_holidays(  # Return default if no language
+            country,
+            subdiv=province,
+            years=year,
+            language=default_language,
+            categories=set_categories,
+        )
+
+    if (
+        default_language
+        and language
+        and language not in supported_languages
+        and language.startswith("en")
+    ):
+        # If language does not match supported languages, use the first English variant
+        if default_language.startswith("en"):
+            LOGGER.debug("Changing language from %s to %s", language, default_language)
+            return country_holidays(  # Return default English if default language
+                country,
+                subdiv=province,
+                years=year,
+                language=default_language,
+                categories=set_categories,
+            )
+        for lang in supported_languages:
+            if lang.startswith("en"):
+                LOGGER.debug("Changing language from %s to %s", language, lang)
+                return country_holidays(
+                    country,
+                    subdiv=province,
+                    years=year,
+                    language=lang,
+                    categories=set_categories,
+                )
+
+    if default_language and language and language not in supported_languages:
+        # If language does not match supported languages, use the default language
+        LOGGER.debug("Changing language from %s to %s", language, default_language)
+        return country_holidays(  # Return default English if default language
+            country,
+            subdiv=province,
+            years=year,
+            language=default_language,
+            categories=set_categories,
+        )
+
+    return obj_holidays
+
+
+def add_remove_custom_holidays(
+    hass: HomeAssistant,
+    entry: "WorkdayConfigEntry",
+    country: str | None,
+    calc_add_holidays: list[DateLike],
+    calc_remove_holidays: list[str],
+) -> None:
+    """Add or remove custom holidays."""
+    next_year = dt_util.now().year + 1
+
+    # Add custom holidays
+    try:
+        entry.runtime_data.append(calc_add_holidays)
+    except ValueError as error:
+        LOGGER.error("Could not add custom holidays: %s", error)
+
+    # Remove custom holidays
+    for remove_holiday in calc_remove_holidays:
+        try:
+            # is this formatted as a date?
+            if dt_util.parse_date(remove_holiday):
+                # remove holiday by date
+                removed = entry.runtime_data.pop(remove_holiday)
+                LOGGER.debug("Removed %s", remove_holiday)
+            else:
+                # remove holiday by name
+                LOGGER.debug("Treating '%s' as named holiday", remove_holiday)
+                removed = entry.runtime_data.pop_named(remove_holiday)
+                for holiday in removed:
+                    LOGGER.debug("Removed %s by name '%s'", holiday, remove_holiday)
+        except KeyError as unmatched:
+            LOGGER.warning("No holiday found matching %s", unmatched)
+            if _date := dt_util.parse_date(remove_holiday):
+                if _date.year <= next_year:
+                    # Only check and raise issues for max next year
+                    async_create_issue(
+                        hass,
+                        DOMAIN,
+                        f"bad_date_holiday-{entry.entry_id}-{slugify(remove_holiday)}",
+                        is_fixable=True,
+                        is_persistent=False,
+                        severity=IssueSeverity.WARNING,
+                        translation_key="bad_date_holiday",
+                        translation_placeholders={
+                            CONF_COUNTRY: country if country else "-",
+                            "title": entry.title,
+                            CONF_REMOVE_HOLIDAYS: remove_holiday,
+                        },
+                        data={
+                            "entry_id": entry.entry_id,
+                            "country": country,
+                            "named_holiday": remove_holiday,
+                        },
+                    )
+            else:
+                async_create_issue(
+                    hass,
+                    DOMAIN,
+                    f"bad_named_holiday-{entry.entry_id}-{slugify(remove_holiday)}",
+                    is_fixable=True,
+                    is_persistent=False,
+                    severity=IssueSeverity.WARNING,
+                    translation_key="bad_named_holiday",
+                    translation_placeholders={
+                        CONF_COUNTRY: country if country else "-",
+                        "title": entry.title,
+                        CONF_REMOVE_HOLIDAYS: remove_holiday,
+                    },
+                    data={
+                        "entry_id": entry.entry_id,
+                        "country": country,
+                        "named_holiday": remove_holiday,
+                    },
+                )

homeassistant/components/wyoming/translations/ga.json

@@ -11,6 +11,11 @@
         }
     },
     "entity": {
+        "binary_sensor": {
+            "assist_in_progress": {
+                "name": "C\u00fanamh ar si\u00fal"
+            }
+        },
         "number": {
             "auto_gain": {
                 "name": "Gn\u00f3thachan uathoibr\u00edoch"
@@ -29,6 +34,20 @@
                     "medium": "Me\u00e1nach",
                     "off": "As"
                 }
+            },
+            "pipeline": {
+                "name": "AssistantC\u00fant\u00f3ir",
+                "state": {
+                    "preferred": "Rogha"
+                }
+            },
+            "vad_sensitivity": {
+                "name": "Braiteadh labhartha cr\u00edochnaithe",
+                "state": {
+                    "aggressive": "Ionsaitheach",
+                    "default": "R\u00e9amhshocr\u00fa",
+                    "relaxed": "Suaimhneach"
+                }
             }
         },
         "switch": {

homeassistant/components/wyoming/translations/it.json

@@ -2,6 +2,7 @@
     "config": {
         "abort": {
             "already_configured": "Il servizio \u00e8 gi\u00e0 configurato",
+            "no_port": "Nessuna porta per l'endpoint",
             "no_services": "Nessun servizio trovato nell'endpoint"
         },
         "error": {
@@ -16,6 +17,10 @@
                     "host": "Host",
                     "port": "Porta"
                 }
+            },
+            "zeroconf_confirm": {
+                "description": "Vuoi configurare Home Assistant per connettersi al servizio Wyoming {name}?",
+                "title": "Servizio Wyoming scoperto"
             }
         }
     },
@@ -25,11 +30,21 @@
                 "name": "Assist in corso"
             }
         },
+        "number": {
+            "auto_gain": {
+                "name": "Guadagno automatico"
+            },
+            "volume_multiplier": {
+                "name": "Volume del microfono"
+            }
+        },
         "select": {
             "noise_suppression_level": {
+                "name": "Livello di soppressione del rumore",
                 "state": {
                     "high": "Alto/a",
                     "low": "Basso/a",
+                    "max": "Massimo",
                     "medium": "Medio/a",
                     "off": "Spento"
                 }

homeassistant/components/xiaomi_ble/manifest.json

@@ -24,5 +24,5 @@
   "dependencies": ["bluetooth_adapters"],
   "documentation": "https://www.home-assistant.io/integrations/xiaomi_ble",
   "iot_class": "local_push",
-  "requirements": ["xiaomi-ble==1.1.0"]
+  "requirements": ["xiaomi-ble==1.2.0"]
 }

homeassistant/components/xiaomi_ble/strings.json

@@ -75,7 +75,7 @@
       "lock_outside_the_door": "Lock outside the door",
       "unlock_outside_the_door": "Unlock outside the door",
       "lock_inside_the_door": "Lock inside the door",
-      "unlock_inside_the_door": "Unlock outside the door",
+      "unlock_inside_the_door": "Unlock inside the door",
       "locked": "Locked",
       "turn_on_antilock": "Turn on antilock",
       "release_the_antilock": "Release antilock",

homeassistant/components/xiaomi_miio/translations/select.ga.json

@@ -0,0 +1,9 @@
+{
+    "state": {
+        "xiaomi_miio__ptc_level": {
+            "high": "Ard",
+            "low": "\u00cdseal",
+            "medium": "Me\u00e1nach"
+        }
+    }
+}

homeassistant/components/yale/manifest.json

@@ -13,5 +13,5 @@
   "documentation": "https://www.home-assistant.io/integrations/yale",
   "iot_class": "cloud_push",
   "loggers": ["socketio", "engineio", "yalexs"],
-  "requirements": ["yalexs==8.11.1", "yalexs-ble==3.1.2"]
+  "requirements": ["yalexs==9.0.1", "yalexs-ble==3.1.2"]
 }

homeassistant/components/yale/translations/ga.json

@@ -43,6 +43,11 @@
                 "name": "D\u00faisigh"
             }
         },
+        "camera": {
+            "camera": {
+                "name": "Ceamara"
+            }
+        },
         "event": {
             "doorbell": {
                 "state_attributes": {

homeassistant/components/yamaha_musiccast/translations/it.json

@@ -18,6 +18,9 @@
                 "data": {
                     "host": "Host"
                 },
+                "data_description": {
+                    "host": "Nome host o indirizzo IP del tuo ricevitore Yamaha MusicCast."
+                },
                 "description": "Configura MusicCast per l'integrazione con Home Assistant."
             }
         }

homeassistant/components/yardian/translations/it.json

@@ -13,6 +13,9 @@
                 "data": {
                     "access_token": "Token di accesso",
                     "host": "Host"
+                },
+                "data_description": {
+                    "host": "Nome host o indirizzo IP del tuo controller Yardian Smart Sprinkler. Puoi trovarlo nell'app Yardian."
                 }
             }
         }

homeassistant/components/yolink/__init__.py

@@ -43,6 +43,7 @@ PLATFORMS = [
     Platform.LIGHT,
     Platform.LOCK,
     Platform.NUMBER,
+    Platform.SELECT,
     Platform.SENSOR,
     Platform.SIREN,
     Platform.SWITCH,

homeassistant/components/yolink/coordinator.py

@@ -5,13 +5,16 @@ from __future__ import annotations
 import asyncio
 from datetime import UTC, datetime, timedelta
 import logging
+from typing import Any
 
+from yolink.client_request import ClientRequest
 from yolink.device import YoLinkDevice
 from yolink.exception import YoLinkAuthFailError, YoLinkClientError
+from yolink.model import BRDP
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed
+from homeassistant.exceptions import ConfigEntryAuthFailed, HomeAssistantError
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
 from .const import ATTR_DEVICE_STATE, ATTR_LORA_INFO, DOMAIN, YOLINK_OFFLINE_TIME
@@ -89,3 +92,16 @@ class YoLinkCoordinator(DataUpdateCoordinator[dict]):
                 self.dev_net_type = dev_lora_info.get("devNetType")
             return device_state
         return {}
+
+    async def call_device(self, request: ClientRequest) -> dict[str, Any]:
+        """Call device api."""
+        try:
+            # call_device will check result, fail by raise YoLinkClientError
+            resp: BRDP = await self.device.call_device(request)
+        except YoLinkAuthFailError as yl_auth_err:
+            self.config_entry.async_start_reauth(self.hass)
+            raise HomeAssistantError(yl_auth_err) from yl_auth_err
+        except YoLinkClientError as yl_client_err:
+            raise HomeAssistantError(yl_client_err) from yl_client_err
+        else:
+            return resp.data

homeassistant/components/yolink/entity.py

@@ -3,13 +3,12 @@
 from __future__ import annotations
 
 from abc import abstractmethod
+from typing import Any
 
 from yolink.client_request import ClientRequest
-from yolink.exception import YoLinkAuthFailError, YoLinkClientError
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import callback
-from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
@@ -64,13 +63,6 @@ class YoLinkEntity(CoordinatorEntity[YoLinkCoordinator]):
     def update_entity_state(self, state: dict) -> None:
         """Parse and update entity state, should be overridden."""
 
-    async def call_device(self, request: ClientRequest) -> None:
+    async def call_device(self, request: ClientRequest) -> dict[str, Any]:
         """Call device api."""
-        try:
-            # call_device will check result, fail by raise YoLinkClientError
-            await self.coordinator.device.call_device(request)
-        except YoLinkAuthFailError as yl_auth_err:
-            self.config_entry.async_start_reauth(self.hass)
-            raise HomeAssistantError(yl_auth_err) from yl_auth_err
-        except YoLinkClientError as yl_client_err:
-            raise HomeAssistantError(yl_client_err) from yl_client_err
+        return await self.coordinator.call_device(request)

homeassistant/components/yolink/icons.json

@@ -27,10 +27,20 @@
         "default": "mdi:gauge"
       }
     },
+    "select": {
+      "sprinkler_mode": {
+        "default": "mdi:auto-mode"
+      }
+    },
     "switch": {
       "manipulator_state": {
         "default": "mdi:pipe"
       }
+    },
+    "valve": {
+      "sprinkler_valve": {
+        "default": "mdi:sprinkler-variant"
+      }
     }
   },
   "services": {

homeassistant/components/yolink/manifest.json

@@ -6,5 +6,5 @@
   "dependencies": ["auth", "application_credentials"],
   "documentation": "https://www.home-assistant.io/integrations/yolink",
   "iot_class": "cloud_push",
-  "requirements": ["yolink-api==0.5.7"]
+  "requirements": ["yolink-api==0.5.8"]
 }

homeassistant/components/yolink/select.py

@@ -0,0 +1,119 @@
+"""YoLink select platform."""
+
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass
+from typing import Any
+
+from yolink.client_request import ClientRequest
+from yolink.const import ATTR_DEVICE_SPRINKLER
+from yolink.device import YoLinkDevice
+from yolink.message_resolver import sprinkler_message_resolve
+
+from homeassistant.components.select import SelectEntity, SelectEntityDescription
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .const import DOMAIN
+from .coordinator import YoLinkCoordinator
+from .entity import YoLinkEntity
+
+
+@dataclass(frozen=True, kw_only=True)
+class YoLinkSelectEntityDescription(SelectEntityDescription):
+    """YoLink SelectEntityDescription."""
+
+    state_key: str = "state"
+    exists_fn: Callable[[YoLinkDevice], bool] = lambda _: True
+    should_update_entity: Callable = lambda state: True
+    value: Callable = lambda data: data
+    on_option_selected: Callable[[YoLinkCoordinator, str], Awaitable[bool]]
+
+
+async def set_sprinker_mode_fn(coordinator: YoLinkCoordinator, option: str) -> bool:
+    """Set sprinkler mode."""
+    data: dict[str, Any] = await coordinator.call_device(
+        ClientRequest(
+            "setState",
+            {
+                "state": {
+                    "mode": option,
+                }
+            },
+        )
+    )
+    sprinkler_message_resolve(coordinator.device, data, None)
+    coordinator.async_set_updated_data(data)
+    return True
+
+
+SELECTOR_MAPPINGS: tuple[YoLinkSelectEntityDescription, ...] = (
+    YoLinkSelectEntityDescription(
+        key="model",
+        options=["auto", "manual", "off"],
+        translation_key="sprinkler_mode",
+        value=lambda data: (
+            data.get("mode") if data is not None else None
+        ),  # watering state report will missing state field
+        exists_fn=lambda device: device.device_type == ATTR_DEVICE_SPRINKLER,
+        should_update_entity=lambda value: value is not None,
+        on_option_selected=set_sprinker_mode_fn,
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: ConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up YoLink select from a config entry."""
+    device_coordinators = hass.data[DOMAIN][config_entry.entry_id].device_coordinators
+    async_add_entities(
+        YoLinkSelectEntity(config_entry, selector_device_coordinator, description)
+        for selector_device_coordinator in device_coordinators.values()
+        if selector_device_coordinator.device.device_type in [ATTR_DEVICE_SPRINKLER]
+        for description in SELECTOR_MAPPINGS
+        if description.exists_fn(selector_device_coordinator.device)
+    )
+
+
+class YoLinkSelectEntity(YoLinkEntity, SelectEntity):
+    """YoLink Select Entity."""
+
+    entity_description: YoLinkSelectEntityDescription
+
+    def __init__(
+        self,
+        config_entry: ConfigEntry,
+        coordinator: YoLinkCoordinator,
+        description: YoLinkSelectEntityDescription,
+    ) -> None:
+        """Init YoLink Select."""
+        super().__init__(config_entry, coordinator)
+        self.entity_description = description
+        self._attr_unique_id = (
+            f"{coordinator.device.device_id} {self.entity_description.key}"
+        )
+
+    @callback
+    def update_entity_state(self, state: dict[str, Any]) -> None:
+        """Update HA Entity State."""
+        if (
+            current_value := self.entity_description.value(
+                state.get(self.entity_description.state_key)
+            )
+        ) is None and self.entity_description.should_update_entity(
+            current_value
+        ) is False:
+            return
+        self._attr_current_option = current_value
+        self.async_write_ha_state()
+
+    async def async_select_option(self, option: str) -> None:
+        """Change the selected option."""
+        if await self.entity_description.on_option_selected(self.coordinator, option):
+            self._attr_current_option = option
+            self.async_write_ha_state()

homeassistant/components/yolink/sensor.py

@@ -23,6 +23,8 @@ from yolink.const import (
     ATTR_DEVICE_SMART_REMOTER,
     ATTR_DEVICE_SMOKE_ALARM,
     ATTR_DEVICE_SOIL_TH_SENSOR,
+    ATTR_DEVICE_SPRINKLER,
+    ATTR_DEVICE_SPRINKLER_V2,
     ATTR_DEVICE_SWITCH,
     ATTR_DEVICE_TH_SENSOR,
     ATTR_DEVICE_THERMOSTAT,
@@ -110,6 +112,8 @@ SENSOR_DEVICE_TYPE = [
     ATTR_GARAGE_DOOR_CONTROLLER,
     ATTR_DEVICE_SOIL_TH_SENSOR,
     ATTR_DEVICE_SMOKE_ALARM,
+    ATTR_DEVICE_SPRINKLER,
+    ATTR_DEVICE_SPRINKLER_V2,
 ]
 
 BATTERY_POWER_SENSOR = [
@@ -131,6 +135,7 @@ BATTERY_POWER_SENSOR = [
     ATTR_DEVICE_MULTI_WATER_METER_CONTROLLER,
     ATTR_DEVICE_SOIL_TH_SENSOR,
     ATTR_DEVICE_SMOKE_ALARM,
+    ATTR_DEVICE_SPRINKLER_V2,
 ]
 
 MCU_DEV_TEMPERATURE_SENSOR = [

homeassistant/components/yolink/strings.json

@@ -121,6 +121,19 @@
       },
       "meter_valve_2_state": {
         "name": "Valve 2"
+      },
+      "sprinkler_valve": {
+        "name": "[%key:component::valve::title%]"
+      }
+    },
+    "select": {
+      "sprinkler_mode": {
+        "name": "Mode",
+        "state": {
+          "auto": "[%key:common::state::auto%]",
+          "manual": "[%key:common::state::manual%]",
+          "off": "[%key:common::state::off%]"
+        }
       }
     }
   },