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

homeassistant/components/workday/__init__.py

@@ -2,103 +2,72 @@
 
 from __future__ import annotations
 
-from functools import partial
+from datetime import timedelta
+from typing import cast
 
-from holidays import HolidayBase, country_holidays
+from holidays import DateLike, HolidayBase
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_COUNTRY, CONF_LANGUAGE
 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 .const import CONF_PROVINCE, DOMAIN, PLATFORMS
-
-
-async def _async_validate_country_and_province(
-    hass: HomeAssistant, entry: ConfigEntry, 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
-
-
-async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+from homeassistant.util import dt as dt_util
+
+from .const import (
+    CONF_ADD_HOLIDAYS,
+    CONF_CATEGORY,
+    CONF_OFFSET,
+    CONF_PROVINCE,
+    CONF_REMOVE_HOLIDAYS,
+    LOGGER,
+    PLATFORMS,
+)
+from .util import (
+    add_remove_custom_holidays,
+    async_validate_country_and_province,
+    get_holidays_object,
+    validate_dates,
+)
+
+type WorkdayConfigEntry = ConfigEntry[HolidayBase]
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: WorkdayConfigEntry) -> bool:
     """Set up Workday from a config entry."""
 
+    calc_add_holidays = cast(
+        list[DateLike], validate_dates(entry.options[CONF_ADD_HOLIDAYS])
+    )
+    calc_remove_holidays: list[str] = validate_dates(
+        entry.options[CONF_REMOVE_HOLIDAYS]
+    )
+    categories: list[str] | None = entry.options.get(CONF_CATEGORY)
     country: str | None = entry.options.get(CONF_COUNTRY)
+    days_offset: int = int(entry.options[CONF_OFFSET])
+    language: str | None = entry.options.get(CONF_LANGUAGE)
     province: str | None = entry.options.get(CONF_PROVINCE)
+    year: int = (dt_util.now() + timedelta(days=days_offset)).year
 
-    await _async_validate_country_and_province(hass, entry, country, province)
-
-    if country and CONF_LANGUAGE not in entry.options:
-        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
-            cls: HolidayBase = await hass.async_add_import_executor_job(
-                partial(country_holidays, country, subdiv=province)
-            )
-        default_language = cls.default_language
-        new_options = entry.options.copy()
-        new_options[CONF_LANGUAGE] = default_language
-        hass.config_entries.async_update_entry(entry, options=new_options)
+    await async_validate_country_and_province(hass, entry, country, province)
+
+    entry.runtime_data = await hass.async_add_executor_job(
+        get_holidays_object, country, province, year, language, categories
+    )
+
+    add_remove_custom_holidays(
+        hass, entry, country, calc_add_holidays, calc_remove_holidays
+    )
+
+    LOGGER.debug("Found the following holidays for your configuration:")
+    for holiday_date, name in sorted(entry.runtime_data.items()):
+        # Make explicit str variable to avoid "Incompatible types in assignment"
+        _holiday_string = holiday_date.strftime("%Y-%m-%d")
+        LOGGER.debug("%s %s", _holiday_string, name)
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
     return True
 
 
-async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_unload_entry(hass: HomeAssistant, entry: WorkdayConfigEntry) -> bool:
     """Unload Workday config entry."""
 
     return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/workday/binary_sensor.py

@@ -2,249 +2,40 @@
 
 from __future__ import annotations
 
-from datetime import date, datetime, timedelta
+from datetime import datetime
 from typing import Final
 
-from holidays import (
-    PUBLIC,
-    HolidayBase,
-    __version__ as python_holidays_version,
-    country_holidays,
-)
+from holidays import HolidayBase
 import voluptuous as vol
 
 from homeassistant.components.binary_sensor import BinarySensorEntity
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_COUNTRY, CONF_LANGUAGE, CONF_NAME
-from homeassistant.core import (
-    CALLBACK_TYPE,
-    HomeAssistant,
-    ServiceResponse,
-    SupportsResponse,
-    callback,
-)
+from homeassistant.const import CONF_NAME
+from homeassistant.core import HomeAssistant, SupportsResponse
 from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
 from homeassistant.helpers.entity_platform import (
     AddConfigEntryEntitiesCallback,
     async_get_current_platform,
 )
-from homeassistant.helpers.event import async_track_point_in_utc_time
-from homeassistant.helpers.issue_registry import IssueSeverity, async_create_issue
-from homeassistant.util import dt as dt_util, slugify
 
-from .const import (
-    ALLOWED_DAYS,
-    CONF_ADD_HOLIDAYS,
-    CONF_CATEGORY,
-    CONF_EXCLUDES,
-    CONF_OFFSET,
-    CONF_PROVINCE,
-    CONF_REMOVE_HOLIDAYS,
-    CONF_WORKDAYS,
-    DOMAIN,
-    LOGGER,
-)
+from . import WorkdayConfigEntry
+from .const import CONF_EXCLUDES, CONF_OFFSET, CONF_WORKDAYS
+from .entity import BaseWorkdayEntity
 
 SERVICE_CHECK_DATE: Final = "check_date"
 CHECK_DATE: Final = "check_date"
 
 
-def validate_dates(holiday_list: list[str]) -> list[str]:
-    """Validate and adds 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_obj_holidays(
-    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
-
-
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: ConfigEntry,
+    entry: WorkdayConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the Workday sensor."""
-    add_holidays: list[str] = entry.options[CONF_ADD_HOLIDAYS]
-    remove_holidays: list[str] = entry.options[CONF_REMOVE_HOLIDAYS]
-    country: str | None = entry.options.get(CONF_COUNTRY)
     days_offset: int = int(entry.options[CONF_OFFSET])
     excludes: list[str] = entry.options[CONF_EXCLUDES]
-    province: str | None = entry.options.get(CONF_PROVINCE)
     sensor_name: str = entry.options[CONF_NAME]
     workdays: list[str] = entry.options[CONF_WORKDAYS]
-    language: str | None = entry.options.get(CONF_LANGUAGE)
-    categories: list[str] | None = entry.options.get(CONF_CATEGORY)
-
-    year: int = (dt_util.now() + timedelta(days=days_offset)).year
-    obj_holidays: HolidayBase = await hass.async_add_executor_job(
-        _get_obj_holidays, country, province, year, language, categories
-    )
-    calc_add_holidays: list[str] = validate_dates(add_holidays)
-    calc_remove_holidays: list[str] = validate_dates(remove_holidays)
-    next_year = dt_util.now().year + 1
-
-    # Add custom holidays
-    try:
-        obj_holidays.append(calc_add_holidays)  # type: ignore[arg-type]
-    except ValueError as error:
-        LOGGER.error("Could not add custom holidays: %s", error)
-
-    # Remove 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 = obj_holidays.pop(remove_holiday)
-                LOGGER.debug("Removed %s", remove_holiday)
-            else:
-                # remove holiday by name
-                LOGGER.debug("Treating '%s' as named holiday", remove_holiday)
-                removed = obj_holidays.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 current and 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,
-                    },
-                )
-
-    LOGGER.debug("Found the following holidays for your configuration:")
-    for holiday_date, name in sorted(obj_holidays.items()):
-        # Make explicit str variable to avoid "Incompatible types in assignment"
-        _holiday_string = holiday_date.strftime("%Y-%m-%d")
-        LOGGER.debug("%s %s", _holiday_string, name)
+    obj_holidays = entry.runtime_data
 
     platform = async_get_current_platform()
     platform.async_register_entity_service(
@@ -269,14 +60,10 @@ async def async_setup_entry(
     )
 
 
-class IsWorkdaySensor(BinarySensorEntity):
+class IsWorkdaySensor(BaseWorkdayEntity, BinarySensorEntity):
     """Implementation of a Workday sensor."""
 
-    _attr_has_entity_name = True
     _attr_name = None
-    _attr_translation_key = DOMAIN
-    _attr_should_poll = False
-    unsub: CALLBACK_TYPE | None = None
 
     def __init__(
         self,
@@ -288,87 +75,20 @@ class IsWorkdaySensor(BinarySensorEntity):
         entry_id: str,
     ) -> None:
         """Initialize the Workday sensor."""
-        self._obj_holidays = obj_holidays
-        self._workdays = workdays
-        self._excludes = excludes
-        self._days_offset = days_offset
+        super().__init__(
+            obj_holidays,
+            workdays,
+            excludes,
+            days_offset,
+            name,
+            entry_id,
+        )
         self._attr_extra_state_attributes = {
             CONF_WORKDAYS: workdays,
             CONF_EXCLUDES: excludes,
             CONF_OFFSET: days_offset,
         }
-        self._attr_unique_id = entry_id
-        self._attr_device_info = DeviceInfo(
-            entry_type=DeviceEntryType.SERVICE,
-            identifiers={(DOMAIN, entry_id)},
-            manufacturer="python-holidays",
-            model=python_holidays_version,
-            name=name,
-        )
-
-    def is_include(self, day: str, now: date) -> bool:
-        """Check if given day is in the includes list."""
-        if day in self._workdays:
-            return True
-        if "holiday" in self._workdays and now in self._obj_holidays:
-            return True
-
-        return False
-
-    def is_exclude(self, day: str, now: date) -> bool:
-        """Check if given day is in the excludes list."""
-        if day in self._excludes:
-            return True
-        if "holiday" in self._excludes and now in self._obj_holidays:
-            return True
-
-        return False
-
-    def get_next_interval(self, now: datetime) -> datetime:
-        """Compute next time an update should occur."""
-        tomorrow = dt_util.as_local(now) + timedelta(days=1)
-        return dt_util.start_of_local_day(tomorrow)
-
-    def _update_state_and_setup_listener(self) -> None:
-        """Update state and setup listener for next interval."""
-        now = dt_util.now()
-        self.update_data(now)
-        self.unsub = async_track_point_in_utc_time(
-            self.hass, self.point_in_time_listener, self.get_next_interval(now)
-        )
-
-    @callback
-    def point_in_time_listener(self, time_date: datetime) -> None:
-        """Get the latest data and update state."""
-        self._update_state_and_setup_listener()
-        self.async_write_ha_state()
-
-    async def async_added_to_hass(self) -> None:
-        """Set up first update."""
-        self._update_state_and_setup_listener()
 
     def update_data(self, now: datetime) -> None:
         """Get date and look whether it is a holiday."""
         self._attr_is_on = self.date_is_workday(now)
-
-    def check_date(self, check_date: date) -> ServiceResponse:
-        """Service to check if date is workday or not."""
-        return {"workday": self.date_is_workday(check_date)}
-
-    def date_is_workday(self, check_date: date) -> bool:
-        """Check if date is workday."""
-        # Default is no workday
-        is_workday = False
-
-        # Get ISO day of the week (1 = Monday, 7 = Sunday)
-        adjusted_date = check_date + timedelta(days=self._days_offset)
-        day = adjusted_date.isoweekday() - 1
-        day_of_week = ALLOWED_DAYS[day]
-
-        if self.is_include(day_of_week, adjusted_date):
-            is_workday = True
-
-        if self.is_exclude(day_of_week, adjusted_date):
-            is_workday = False
-
-        return is_workday

homeassistant/components/workday/entity.py

@@ -0,0 +1,115 @@
+"""Base workday entity."""
+
+from __future__ import annotations
+
+from abc import abstractmethod
+from datetime import date, datetime, timedelta
+
+from holidays import HolidayBase, __version__ as python_holidays_version
+
+from homeassistant.core import CALLBACK_TYPE, ServiceResponse, callback
+from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
+from homeassistant.helpers.entity import Entity
+from homeassistant.helpers.event import async_track_point_in_utc_time
+from homeassistant.util import dt as dt_util
+
+from .const import ALLOWED_DAYS, DOMAIN
+
+
+class BaseWorkdayEntity(Entity):
+    """Implementation of a base Workday entity."""
+
+    _attr_has_entity_name = True
+    _attr_translation_key = DOMAIN
+    _attr_should_poll = False
+    unsub: CALLBACK_TYPE | None = None
+
+    def __init__(
+        self,
+        obj_holidays: HolidayBase,
+        workdays: list[str],
+        excludes: list[str],
+        days_offset: int,
+        name: str,
+        entry_id: str,
+    ) -> None:
+        """Initialize the Workday entity."""
+        self._obj_holidays = obj_holidays
+        self._workdays = workdays
+        self._excludes = excludes
+        self._days_offset = days_offset
+        self._attr_unique_id = entry_id
+        self._attr_device_info = DeviceInfo(
+            entry_type=DeviceEntryType.SERVICE,
+            identifiers={(DOMAIN, entry_id)},
+            manufacturer="python-holidays",
+            model=python_holidays_version,
+            name=name,
+        )
+
+    def is_include(self, day: str, now: date) -> bool:
+        """Check if given day is in the includes list."""
+        if day in self._workdays:
+            return True
+        if "holiday" in self._workdays and now in self._obj_holidays:
+            return True
+
+        return False
+
+    def is_exclude(self, day: str, now: date) -> bool:
+        """Check if given day is in the excludes list."""
+        if day in self._excludes:
+            return True
+        if "holiday" in self._excludes and now in self._obj_holidays:
+            return True
+
+        return False
+
+    def get_next_interval(self, now: datetime) -> datetime:
+        """Compute next time an update should occur."""
+        tomorrow = dt_util.as_local(now) + timedelta(days=1)
+        return dt_util.start_of_local_day(tomorrow)
+
+    def _update_state_and_setup_listener(self) -> None:
+        """Update state and setup listener for next interval."""
+        now = dt_util.now()
+        self.update_data(now)
+        self.unsub = async_track_point_in_utc_time(
+            self.hass, self.point_in_time_listener, self.get_next_interval(now)
+        )
+
+    @callback
+    def point_in_time_listener(self, time_date: datetime) -> None:
+        """Get the latest data and update state."""
+        self._update_state_and_setup_listener()
+        self.async_write_ha_state()
+
+    async def async_added_to_hass(self) -> None:
+        """Set up first update."""
+        self._update_state_and_setup_listener()
+
+    @abstractmethod
+    def update_data(self, now: datetime) -> None:
+        """Update data."""
+
+    def check_date(self, check_date: date) -> ServiceResponse:
+        """Service to check if date is workday or not."""
+        return {"workday": self.date_is_workday(check_date)}
+
+    def date_is_workday(self, check_date: date) -> bool:
+        """Check if date is workday."""
+        # Default is no workday
+        is_workday = False
+
+        # Get ISO day of the week (1 = Monday, 7 = Sunday)
+        adjusted_date = check_date + timedelta(days=self._days_offset)
+        day = adjusted_date.isoweekday() - 1
+        day_of_week = ALLOWED_DAYS[day]
+
+        if self.is_include(day_of_week, adjusted_date):
+            is_workday = True
+
+        if self.is_exclude(day_of_week, adjusted_date):
+            is_workday = False
+
+        return is_workday

homeassistant/components/workday/translations/it.json

@@ -16,6 +16,7 @@
                 },
                 "data_description": {
                     "add_holidays": "Aggiungi festivit\u00e0 personalizzate come AAAA-MM-GG o come intervallo usando ',' come separatore",
+                    "language": "Lingua da utilizzare quando si configurano le esclusioni per le vacanze nominate",
                     "remove_holidays": "Rimuovi le festivit\u00e0 come AAAA-MM-GG, come intervallo usando ',' come separatore o usando il nome parziale"
                 },
                 "description": "Imposta opzioni aggiuntive per {name} configurato per il paese {country}"
@@ -148,7 +149,7 @@
                     "add_holidays": "Aggiungi festivit\u00e0 personalizzate come AAAA-MM-GG o come intervallo usando ',' come separatore",
                     "days_offset": "Scostamento dei giorni",
                     "excludes": "Elenco dei giorni lavorativi da escludere",
-                    "language": "Scegli la lingua in base alla quale desideri configurare le festivit\u00e0 con nome",
+                    "language": "Lingua da utilizzare quando si configurano le esclusioni per le vacanze nominate",
                     "province": "Stato, Territorio, Provincia, Regione della Nazione",
                     "remove_holidays": "Rimuovi le festivit\u00e0 come AAAA-MM-GG, come intervallo usando ',' come separatore o usando il nome parziale",
                     "workdays": "Elenco dei giorni lavorativi"