core/homeassistant/components/template/weather.py

"""Template platform that aggregates meteorological data."""

from __future__ import annotations

from collections.abc import Callable
from dataclasses import asdict, dataclass
from functools import partial
from typing import TYPE_CHECKING, Any, Literal, Self

import voluptuous as vol

from homeassistant.components.weather import (
    ATTR_CONDITION_CLEAR_NIGHT,
    ATTR_CONDITION_CLOUDY,
    ATTR_CONDITION_EXCEPTIONAL,
    ATTR_CONDITION_FOG,
    ATTR_CONDITION_HAIL,
    ATTR_CONDITION_LIGHTNING,
    ATTR_CONDITION_LIGHTNING_RAINY,
    ATTR_CONDITION_PARTLYCLOUDY,
    ATTR_CONDITION_POURING,
    ATTR_CONDITION_RAINY,
    ATTR_CONDITION_SNOWY,
    ATTR_CONDITION_SNOWY_RAINY,
    ATTR_CONDITION_SUNNY,
    ATTR_CONDITION_WINDY,
    ATTR_CONDITION_WINDY_VARIANT,
    DOMAIN as WEATHER_DOMAIN,
    ENTITY_ID_FORMAT,
    PLATFORM_SCHEMA as WEATHER_PLATFORM_SCHEMA,
    Forecast,
    WeatherEntity,
    WeatherEntityFeature,
)
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import (
    CONF_NAME,
    CONF_TEMPERATURE_UNIT,
    CONF_UNIQUE_ID,
    STATE_UNAVAILABLE,
    STATE_UNKNOWN,
)
from homeassistant.core import HomeAssistant, callback
from homeassistant.exceptions import TemplateError
from homeassistant.helpers import config_validation as cv, template
from homeassistant.helpers.entity_platform import (
    AddConfigEntryEntitiesCallback,
    AddEntitiesCallback,
)
from homeassistant.helpers.restore_state import ExtraStoredData, RestoreEntity
from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
from homeassistant.util.unit_conversion import (
    DistanceConverter,
    PressureConverter,
    SpeedConverter,
    TemperatureConverter,
)

from .coordinator import TriggerUpdateCoordinator
from .entity import AbstractTemplateEntity
from .helpers import (
    async_setup_template_entry,
    async_setup_template_platform,
    async_setup_template_preview,
    rewrite_legacy_to_modern_config,
)
from .schemas import (
    TEMPLATE_ENTITY_COMMON_CONFIG_ENTRY_SCHEMA,
    make_template_entity_common_modern_schema,
)
from .template_entity import TemplateEntity
from .trigger_entity import TriggerEntity

CHECK_FORECAST_KEYS = (
    set()
    .union(Forecast.__annotations__.keys())
    # Manually add the forecast resulting attributes that only exists
    #  as native_* in the Forecast definition
    .union(("apparent_temperature", "wind_gust_speed", "dew_point"))
)

CONDITION_CLASSES = {
    ATTR_CONDITION_CLEAR_NIGHT,
    ATTR_CONDITION_CLOUDY,
    ATTR_CONDITION_FOG,
    ATTR_CONDITION_HAIL,
    ATTR_CONDITION_LIGHTNING,
    ATTR_CONDITION_LIGHTNING_RAINY,
    ATTR_CONDITION_PARTLYCLOUDY,
    ATTR_CONDITION_POURING,
    ATTR_CONDITION_RAINY,
    ATTR_CONDITION_SNOWY,
    ATTR_CONDITION_SNOWY_RAINY,
    ATTR_CONDITION_SUNNY,
    ATTR_CONDITION_WINDY,
    ATTR_CONDITION_WINDY_VARIANT,
    ATTR_CONDITION_EXCEPTIONAL,
}

CONF_APPARENT_TEMPERATURE = "apparent_temperature"
CONF_APPARENT_TEMPERATURE_TEMPLATE = "apparent_temperature_template"
CONF_ATTRIBUTION = "attribution"
CONF_ATTRIBUTION_TEMPLATE = "attribution_template"
CONF_CLOUD_COVERAGE = "cloud_coverage"
CONF_CLOUD_COVERAGE_TEMPLATE = "cloud_coverage_template"
CONF_CONDITION = "condition"
CONF_CONDITION_TEMPLATE = "condition_template"
CONF_DEW_POINT = "dew_point"
CONF_DEW_POINT_TEMPLATE = "dew_point_template"
CONF_FORECAST_DAILY = "forecast_daily"
CONF_FORECAST_DAILY_TEMPLATE = "forecast_daily_template"
CONF_FORECAST_HOURLY = "forecast_hourly"
CONF_FORECAST_HOURLY_TEMPLATE = "forecast_hourly_template"
CONF_FORECAST_TWICE_DAILY = "forecast_twice_daily"
CONF_FORECAST_TWICE_DAILY_TEMPLATE = "forecast_twice_daily_template"
CONF_HUMIDITY = "humidity"
CONF_HUMIDITY_TEMPLATE = "humidity_template"
CONF_OZONE = "ozone"
CONF_OZONE_TEMPLATE = "ozone_template"
CONF_PRECIPITATION_UNIT = "precipitation_unit"
CONF_PRESSURE = "pressure"
CONF_PRESSURE_TEMPLATE = "pressure_template"
CONF_PRESSURE_UNIT = "pressure_unit"
CONF_TEMPERATURE = "temperature"
CONF_TEMPERATURE_TEMPLATE = "temperature_template"
CONF_UV_INDEX = "uv_index"
CONF_UV_INDEX_TEMPLATE = "uv_index_template"
CONF_VISIBILITY = "visibility"
CONF_VISIBILITY_TEMPLATE = "visibility_template"
CONF_VISIBILITY_UNIT = "visibility_unit"
CONF_WEATHER = "weather"
CONF_WIND_BEARING = "wind_bearing"
CONF_WIND_BEARING_TEMPLATE = "wind_bearing_template"
CONF_WIND_GUST_SPEED = "wind_gust_speed"
CONF_WIND_GUST_SPEED_TEMPLATE = "wind_gust_speed_template"
CONF_WIND_SPEED = "wind_speed"
CONF_WIND_SPEED_TEMPLATE = "wind_speed_template"
CONF_WIND_SPEED_UNIT = "wind_speed_unit"

DEFAULT_NAME = "Template Weather"

LEGACY_FIELDS = {
    CONF_APPARENT_TEMPERATURE_TEMPLATE: CONF_APPARENT_TEMPERATURE,
    CONF_ATTRIBUTION_TEMPLATE: CONF_ATTRIBUTION,
    CONF_CLOUD_COVERAGE_TEMPLATE: CONF_CLOUD_COVERAGE,
    CONF_CONDITION_TEMPLATE: CONF_CONDITION,
    CONF_DEW_POINT_TEMPLATE: CONF_DEW_POINT,
    CONF_FORECAST_DAILY_TEMPLATE: CONF_FORECAST_DAILY,
    CONF_FORECAST_HOURLY_TEMPLATE: CONF_FORECAST_HOURLY,
    CONF_FORECAST_TWICE_DAILY_TEMPLATE: CONF_FORECAST_TWICE_DAILY,
    CONF_HUMIDITY_TEMPLATE: CONF_HUMIDITY,
    CONF_OZONE_TEMPLATE: CONF_OZONE,
    CONF_PRESSURE_TEMPLATE: CONF_PRESSURE,
    CONF_TEMPERATURE_TEMPLATE: CONF_TEMPERATURE,
    CONF_UV_INDEX_TEMPLATE: CONF_UV_INDEX,
    CONF_VISIBILITY_TEMPLATE: CONF_VISIBILITY,
    CONF_WIND_BEARING_TEMPLATE: CONF_WIND_BEARING,
    CONF_WIND_GUST_SPEED_TEMPLATE: CONF_WIND_GUST_SPEED,
    CONF_WIND_SPEED_TEMPLATE: CONF_WIND_SPEED,
}


WEATHER_COMMON_SCHEMA = vol.Schema(
    {
        vol.Optional(CONF_APPARENT_TEMPERATURE_TEMPLATE): cv.template,
        vol.Optional(CONF_ATTRIBUTION_TEMPLATE): cv.template,
        vol.Optional(CONF_CLOUD_COVERAGE_TEMPLATE): cv.template,
        vol.Required(CONF_CONDITION_TEMPLATE): cv.template,
        vol.Optional(CONF_DEW_POINT_TEMPLATE): cv.template,
        vol.Optional(CONF_FORECAST_DAILY_TEMPLATE): cv.template,
        vol.Optional(CONF_FORECAST_HOURLY_TEMPLATE): cv.template,
        vol.Optional(CONF_FORECAST_TWICE_DAILY_TEMPLATE): cv.template,
        vol.Required(CONF_HUMIDITY_TEMPLATE): cv.template,
        vol.Optional(CONF_OZONE_TEMPLATE): cv.template,
        vol.Optional(CONF_PRECIPITATION_UNIT): vol.In(DistanceConverter.VALID_UNITS),
        vol.Optional(CONF_PRESSURE_TEMPLATE): cv.template,
        vol.Optional(CONF_PRESSURE_UNIT): vol.In(PressureConverter.VALID_UNITS),
        vol.Required(CONF_TEMPERATURE_TEMPLATE): cv.template,
        vol.Optional(CONF_TEMPERATURE_UNIT): vol.In(TemperatureConverter.VALID_UNITS),
        vol.Optional(CONF_VISIBILITY_TEMPLATE): cv.template,
        vol.Optional(CONF_VISIBILITY_UNIT): vol.In(DistanceConverter.VALID_UNITS),
        vol.Optional(CONF_WIND_BEARING_TEMPLATE): cv.template,
        vol.Optional(CONF_WIND_GUST_SPEED_TEMPLATE): cv.template,
        vol.Optional(CONF_WIND_SPEED_TEMPLATE): cv.template,
        vol.Optional(CONF_WIND_SPEED_UNIT): vol.In(SpeedConverter.VALID_UNITS),
    }
)


WEATHER_YAML_SCHEMA = (
    vol.Schema(
        {
            vol.Optional(CONF_UV_INDEX_TEMPLATE): cv.template,
        }
    )
    .extend(WEATHER_COMMON_SCHEMA.schema)
    .extend(
        make_template_entity_common_modern_schema(WEATHER_DOMAIN, DEFAULT_NAME).schema
    )
)

PLATFORM_SCHEMA = (
    vol.Schema(
        {
            vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.template,
            vol.Optional(CONF_UNIQUE_ID): cv.string,
        }
    )
    .extend(WEATHER_COMMON_SCHEMA.schema)
    .extend(WEATHER_PLATFORM_SCHEMA.schema)
)


WEATHER_CONFIG_ENTRY_SCHEMA = vol.Schema(
    {
        vol.Optional(CONF_APPARENT_TEMPERATURE): cv.template,
        vol.Optional(CONF_ATTRIBUTION): cv.template,
        vol.Optional(CONF_CLOUD_COVERAGE): cv.template,
        vol.Required(CONF_CONDITION): cv.template,
        vol.Optional(CONF_DEW_POINT): cv.template,
        vol.Optional(CONF_FORECAST_DAILY): cv.template,
        vol.Optional(CONF_FORECAST_HOURLY): cv.template,
        vol.Optional(CONF_FORECAST_TWICE_DAILY): cv.template,
        vol.Required(CONF_HUMIDITY): cv.template,
        vol.Optional(CONF_OZONE): cv.template,
        vol.Optional(CONF_PRECIPITATION_UNIT): vol.In(DistanceConverter.VALID_UNITS),
        vol.Optional(CONF_PRESSURE): cv.template,
        vol.Optional(CONF_PRESSURE_UNIT): vol.In(PressureConverter.VALID_UNITS),
        vol.Required(CONF_TEMPERATURE): cv.template,
        vol.Optional(CONF_TEMPERATURE_UNIT): vol.In(TemperatureConverter.VALID_UNITS),
        vol.Optional(CONF_UV_INDEX): cv.template,
        vol.Optional(CONF_VISIBILITY): cv.template,
        vol.Optional(CONF_VISIBILITY_UNIT): vol.In(DistanceConverter.VALID_UNITS),
        vol.Optional(CONF_WIND_BEARING): cv.template,
        vol.Optional(CONF_WIND_GUST_SPEED): cv.template,
        vol.Optional(CONF_WIND_SPEED): cv.template,
        vol.Optional(CONF_WIND_SPEED_UNIT): vol.In(SpeedConverter.VALID_UNITS),
    }
).extend(TEMPLATE_ENTITY_COMMON_CONFIG_ENTRY_SCHEMA.schema)


async def async_setup_platform(
    hass: HomeAssistant,
    config: ConfigType,
    async_add_entities: AddEntitiesCallback,
    discovery_info: DiscoveryInfoType | None = None,
) -> None:
    """Set up the Template weather."""

    # Rewrite the configuration options to modern keys.
    if discovery_info is None:
        # Legacy
        config = rewrite_legacy_to_modern_config(hass, config, LEGACY_FIELDS)
    else:
        # Modern and Trigger
        entity_configs: list[ConfigType] = discovery_info["entities"]
        modified_entity_configs = []
        for entity_config in entity_configs:
            entity_config = rewrite_legacy_to_modern_config(
                hass, entity_config, LEGACY_FIELDS
            )

            modified_entity_configs.append(entity_config)

        if modified_entity_configs:
            discovery_info["entities"] = modified_entity_configs

    await async_setup_template_platform(
        hass,
        WEATHER_DOMAIN,
        config,
        StateWeatherEntity,
        TriggerWeatherEntity,
        async_add_entities,
        discovery_info,
        {},
    )


async def async_setup_entry(
    hass: HomeAssistant,
    config_entry: ConfigEntry,
    async_add_entities: AddConfigEntryEntitiesCallback,
) -> None:
    """Initialize config entry."""
    await async_setup_template_entry(
        hass,
        config_entry,
        async_add_entities,
        StateWeatherEntity,
        WEATHER_CONFIG_ENTRY_SCHEMA,
    )


@callback
def async_create_preview_weather(
    hass: HomeAssistant, name: str, config: dict[str, Any]
) -> StateWeatherEntity:
    """Create a preview."""
    return async_setup_template_preview(
        hass,
        name,
        config,
        StateWeatherEntity,
        WEATHER_CONFIG_ENTRY_SCHEMA,
    )


class AbstractTemplateWeather(AbstractTemplateEntity, WeatherEntity):
    """Representation of a template weathers features."""

    _entity_id_format = ENTITY_ID_FORMAT
    _optimistic_entity = True

    # The super init is not called because TemplateEntity and TriggerEntity will call AbstractTemplateEntity.__init__.
    # This ensures that the __init__ on AbstractTemplateEntity is not called twice.
    def __init__(  # pylint: disable=super-init-not-called
        self, config: dict[str, Any], initial_state: bool | None = False
    ) -> None:
        """Initialize the features."""

        # Templates
        self._apparent_temperature_template = config.get(CONF_APPARENT_TEMPERATURE)
        self._attribution_template = config.get(CONF_ATTRIBUTION)
        self._cloud_coverage_template = config.get(CONF_CLOUD_COVERAGE)
        self._condition_template = config[CONF_CONDITION]
        self._dew_point_template = config.get(CONF_DEW_POINT)
        self._forecast_daily_template = config.get(CONF_FORECAST_DAILY)
        self._forecast_hourly_template = config.get(CONF_FORECAST_HOURLY)
        self._forecast_twice_daily_template = config.get(CONF_FORECAST_TWICE_DAILY)
        self._humidity_template = config[CONF_HUMIDITY]
        self._ozone_template = config.get(CONF_OZONE)
        self._pressure_template = config.get(CONF_PRESSURE)
        self._temperature_template = config[CONF_TEMPERATURE]
        self._uv_index_template = config.get(CONF_UV_INDEX)
        self._visibility_template = config.get(CONF_VISIBILITY)
        self._wind_bearing_template = config.get(CONF_WIND_BEARING)
        self._wind_gust_speed_template = config.get(CONF_WIND_GUST_SPEED)
        self._wind_speed_template = config.get(CONF_WIND_SPEED)

        # Legacy support
        self._attribution: str | None = None

        # Native units
        self._attr_native_precipitation_unit = config.get(CONF_PRECIPITATION_UNIT)
        self._attr_native_pressure_unit = config.get(CONF_PRESSURE_UNIT)
        self._attr_native_temperature_unit = config.get(CONF_TEMPERATURE_UNIT)
        self._attr_native_visibility_unit = config.get(CONF_VISIBILITY_UNIT)
        self._attr_native_wind_speed_unit = config.get(CONF_WIND_SPEED_UNIT)

        # Supported Features
        self._attr_supported_features = 0
        if self._forecast_daily_template:
            self._attr_supported_features |= WeatherEntityFeature.FORECAST_DAILY
        if self._forecast_hourly_template:
            self._attr_supported_features |= WeatherEntityFeature.FORECAST_HOURLY
        if self._forecast_twice_daily_template:
            self._attr_supported_features |= WeatherEntityFeature.FORECAST_TWICE_DAILY

    @property
    def attribution(self) -> str | None:
        """Return the attribution."""
        if self._attribution is None:
            return "Powered by Home Assistant"
        return self._attribution

    def _validate[T](
        self,
        validator: Callable[[Any], T],
        result: Any,
    ) -> T | None:
        try:
            return validator(result)
        except vol.Invalid:
            return None

    @callback
    def _update_apparent_temperature(self, result: Any) -> None:
        self._attr_native_apparent_temperature = self._validate(
            vol.Coerce(float), result
        )

    @callback
    def _update_attribution(self, result: Any) -> None:
        self._attribution = vol.Coerce(str)(result)

    @callback
    def _update_condition(self, result: Any) -> None:
        self._attr_condition = result if result in CONDITION_CLASSES else None

    @callback
    def _update_coverage(self, result: Any) -> None:
        self._attr_cloud_coverage = self._validate(vol.Coerce(float), result)

    @callback
    def _update_dew_point(self, result: Any) -> None:
        self._attr_native_dew_point = self._validate(vol.Coerce(float), result)

    @callback
    def _update_humidity(self, result: Any) -> None:
        self._attr_humidity = self._validate(vol.Coerce(float), result)

    @callback
    def _update_ozone(self, result: Any) -> None:
        self._attr_ozone = self._validate(vol.Coerce(float), result)

    @callback
    def _update_pressure(self, result: Any) -> None:
        self._attr_native_pressure = self._validate(vol.Coerce(float), result)

    @callback
    def _update_temperature(self, result: Any) -> None:
        self._attr_native_temperature = self._validate(vol.Coerce(float), result)

    @callback
    def _update_uv_index(self, result: Any) -> None:
        self._attr_uv_index = self._validate(vol.Coerce(float), result)

    @callback
    def _update_visibility(self, result: Any) -> None:
        self._attr_native_visibility = self._validate(vol.Coerce(float), result)

    @callback
    def _update_wind_bearing(self, result: Any) -> None:
        try:
            self._attr_wind_bearing = vol.Coerce(float)(result)
        except vol.Invalid:
            self._attr_wind_bearing = vol.Coerce(str)(result)

    @callback
    def _update_wind_gust_speed(self, result: Any) -> None:
        self._attr_native_wind_gust_speed = self._validate(vol.Coerce(float), result)

    @callback
    def _update_wind_speed(self, result: Any) -> None:
        self._attr_native_wind_speed = self._validate(vol.Coerce(float), result)

    @callback
    def _validate_forecast(
        self,
        forecast_type: Literal["daily", "hourly", "twice_daily"],
        result: Any,
    ) -> list[Forecast] | None:
        """Validate the forecasts."""
        if result is None:
            return None

        if not isinstance(result, list):
            raise vol.Invalid(
                "Forecasts is not a list, see Weather documentation https://www.home-assistant.io/integrations/weather/"
            )
        for forecast in result:
            if not isinstance(forecast, dict):
                raise vol.Invalid(
                    "Forecast in list is not a dict, see Weather documentation https://www.home-assistant.io/integrations/weather/"
                )
            diff_result = set().union(forecast.keys()).difference(CHECK_FORECAST_KEYS)
            if diff_result:
                raise vol.Invalid(
                    f"Only valid keys in Forecast are allowed, unallowed keys: ({diff_result}), "
                    "see Weather documentation https://www.home-assistant.io/integrations/weather/"
                )
            if forecast_type == "twice_daily" and "is_daytime" not in forecast:
                raise vol.Invalid(
                    "`is_daytime` is missing in twice_daily forecast, see Weather documentation https://www.home-assistant.io/integrations/weather/"
                )
            if "datetime" not in forecast:
                raise vol.Invalid(
                    "`datetime` is required in forecasts, see Weather documentation https://www.home-assistant.io/integrations/weather/"
                )
            continue
        return result


class StateWeatherEntity(TemplateEntity, AbstractTemplateWeather):
    """Representation of a Template weather."""

    _attr_should_poll = False

    def __init__(
        self,
        hass: HomeAssistant,
        config: ConfigType,
        unique_id: str | None,
    ) -> None:
        """Initialize the Template weather."""
        TemplateEntity.__init__(self, hass, config, unique_id)
        AbstractTemplateWeather.__init__(self, config)

        name = self._attr_name
        if TYPE_CHECKING:
            assert name is not None

        # Forecasts
        self._forecast_daily: list[Forecast] | None = []
        self._forecast_hourly: list[Forecast] | None = []
        self._forecast_twice_daily: list[Forecast] | None = []

    @callback
    def _async_setup_templates(self) -> None:
        """Set up templates."""

        if self._apparent_temperature_template:
            self.add_template_attribute(
                "_attr_native_apparent_temperature",
                self._apparent_temperature_template,
                on_update=self._update_apparent_temperature,
            )
        if self._attribution_template:
            self.add_template_attribute(
                "_attribution",
                self._attribution_template,
                on_update=self._update_attribution,
            )
        if self._cloud_coverage_template:
            self.add_template_attribute(
                "_attr_cloud_coverage",
                self._cloud_coverage_template,
                on_update=self._update_coverage,
            )
        if self._condition_template:
            self.add_template_attribute(
                "_attr_condition",
                self._condition_template,
                on_update=self._update_condition,
            )
        if self._dew_point_template:
            self.add_template_attribute(
                "_attr_native_dew_point",
                self._dew_point_template,
                on_update=self._update_dew_point,
            )
        if self._forecast_daily_template:
            self.add_template_attribute(
                "_forecast_daily",
                self._forecast_daily_template,
                on_update=partial(self._update_forecast, "daily"),
                validator=partial(self._validate_forecast, "daily"),
            )
        if self._forecast_hourly_template:
            self.add_template_attribute(
                "_forecast_hourly",
                self._forecast_hourly_template,
                on_update=partial(self._update_forecast, "hourly"),
                validator=partial(self._validate_forecast, "hourly"),
            )
        if self._forecast_twice_daily_template:
            self.add_template_attribute(
                "_forecast_twice_daily",
                self._forecast_twice_daily_template,
                on_update=partial(self._update_forecast, "twice_daily"),
                validator=partial(self._validate_forecast, "twice_daily"),
            )
        if self._humidity_template:
            self.add_template_attribute(
                "_attr_humidity",
                self._humidity_template,
                on_update=self._update_humidity,
            )
        if self._ozone_template:
            self.add_template_attribute(
                "_attr_ozone",
                self._ozone_template,
                on_update=self._update_ozone,
            )
        if self._pressure_template:
            self.add_template_attribute(
                "_attr_native_pressure",
                self._pressure_template,
                on_update=self._update_pressure,
            )
        if self._temperature_template:
            self.add_template_attribute(
                "_attr_native_temperature",
                self._temperature_template,
                on_update=self._update_temperature,
            )
        if self._uv_index_template:
            self.add_template_attribute(
                "_attr_uv_index",
                self._uv_index_template,
                on_update=self._update_uv_index,
            )
        if self._visibility_template:
            self.add_template_attribute(
                "_attr_native_visibility",
                self._visibility_template,
                on_update=self._update_visibility,
            )
        if self._wind_bearing_template:
            self.add_template_attribute(
                "_attr_wind_bearing",
                self._wind_bearing_template,
                on_update=self._update_wind_bearing,
            )
        if self._wind_gust_speed_template:
            self.add_template_attribute(
                "_attr_native_wind_gust_speed",
                self._wind_gust_speed_template,
                on_update=self._update_wind_gust_speed,
            )
        if self._wind_speed_template:
            self.add_template_attribute(
                "_attr_native_wind_speed",
                self._wind_speed_template,
                on_update=self._update_wind_speed,
            )

        super()._async_setup_templates()

    async def async_forecast_daily(self) -> list[Forecast]:
        """Return the daily forecast in native units."""
        return self._forecast_daily or []

    async def async_forecast_hourly(self) -> list[Forecast]:
        """Return the daily forecast in native units."""
        return self._forecast_hourly or []

    async def async_forecast_twice_daily(self) -> list[Forecast]:
        """Return the daily forecast in native units."""
        return self._forecast_twice_daily or []

    @callback
    def _update_forecast(
        self,
        forecast_type: Literal["daily", "hourly", "twice_daily"],
        result: list[Forecast] | TemplateError,
    ) -> None:
        """Save template result and trigger forecast listener."""
        attr_result = None if isinstance(result, TemplateError) else result
        setattr(self, f"_forecast_{forecast_type}", attr_result)
        self.hass.async_create_task(
            self.async_update_listeners([forecast_type]), eager_start=True
        )


@dataclass(kw_only=True)
class WeatherExtraStoredData(ExtraStoredData):
    """Object to hold extra stored data."""

    last_apparent_temperature: float | None
    last_cloud_coverage: int | None
    last_dew_point: float | None
    last_humidity: float | None
    last_ozone: float | None
    last_pressure: float | None
    last_temperature: float | None
    last_uv_index: float | None
    last_visibility: float | None
    last_wind_bearing: float | str | None
    last_wind_gust_speed: float | None
    last_wind_speed: float | None

    def as_dict(self) -> dict[str, Any]:
        """Return a dict representation of the event data."""
        return asdict(self)

    @classmethod
    def from_dict(cls, restored: dict[str, Any]) -> Self | None:
        """Initialize a stored event state from a dict."""
        try:
            return cls(
                last_apparent_temperature=restored["last_apparent_temperature"],
                last_cloud_coverage=restored["last_cloud_coverage"],
                last_dew_point=restored["last_dew_point"],
                last_humidity=restored["last_humidity"],
                last_ozone=restored["last_ozone"],
                last_pressure=restored["last_pressure"],
                last_temperature=restored["last_temperature"],
                last_uv_index=restored["last_uv_index"],
                last_visibility=restored["last_visibility"],
                last_wind_bearing=restored["last_wind_bearing"],
                last_wind_gust_speed=restored["last_wind_gust_speed"],
                last_wind_speed=restored["last_wind_speed"],
            )
        except KeyError:
            return None


class TriggerWeatherEntity(TriggerEntity, AbstractTemplateWeather, RestoreEntity):
    """Weather entity based on trigger data."""

    domain = WEATHER_DOMAIN
    extra_template_keys = (
        CONF_CONDITION,
        CONF_TEMPERATURE,
        CONF_HUMIDITY,
    )

    def __init__(
        self,
        hass: HomeAssistant,
        coordinator: TriggerUpdateCoordinator,
        config: ConfigType,
    ) -> None:
        """Initialize."""
        TriggerEntity.__init__(self, hass, coordinator, config)
        AbstractTemplateWeather.__init__(self, config, None)

        for key in (
            CONF_APPARENT_TEMPERATURE,
            CONF_CLOUD_COVERAGE,
            CONF_DEW_POINT,
            CONF_FORECAST_DAILY,
            CONF_FORECAST_HOURLY,
            CONF_FORECAST_TWICE_DAILY,
            CONF_OZONE,
            CONF_PRESSURE,
            CONF_UV_INDEX,
            CONF_VISIBILITY,
            CONF_WIND_BEARING,
            CONF_WIND_GUST_SPEED,
            CONF_WIND_SPEED,
        ):
            if isinstance(config.get(key), template.Template):
                self._to_render_simple.append(key)
                self._parse_result.add(key)

    async def async_added_to_hass(self) -> None:
        """Restore last state."""
        await super().async_added_to_hass()
        if (
            (state := await self.async_get_last_state())
            and state.state is not None
            and state.state not in (STATE_UNKNOWN, STATE_UNAVAILABLE)
            and (weather_data := await self.async_get_last_weather_data())
        ):
            self._attr_native_apparent_temperature = (
                weather_data.last_apparent_temperature
            )
            self._attr_cloud_coverage = weather_data.last_cloud_coverage
            self._attr_condition = state.state
            self._attr_native_dew_point = weather_data.last_dew_point
            self._attr_humidity = weather_data.last_humidity
            self._attr_ozone = weather_data.last_ozone
            self._attr_native_pressure = weather_data.last_pressure
            self._attr_native_temperature = weather_data.last_temperature
            self._attr_uv_index = weather_data.last_uv_index
            self._attr_native_visibility = weather_data.last_visibility
            self._attr_wind_bearing = weather_data.last_wind_bearing
            self._attr_native_wind_gust_speed = weather_data.last_wind_gust_speed
            self._attr_native_wind_speed = weather_data.last_wind_speed

    @callback
    def _handle_coordinator_update(self) -> None:
        """Handle update of the data."""
        self._process_data()

        if not self.available:
            self.async_write_ha_state()
            return

        write_ha_state = False
        for key, updater in (
            (CONF_APPARENT_TEMPERATURE, self._update_apparent_temperature),
            (CONF_CLOUD_COVERAGE, self._update_coverage),
            (CONF_CONDITION, self._update_condition),
            (CONF_DEW_POINT, self._update_dew_point),
            (CONF_HUMIDITY, self._update_humidity),
            (CONF_OZONE, self._update_ozone),
            (CONF_PRESSURE, self._update_pressure),
            (CONF_TEMPERATURE, self._update_temperature),
            (CONF_UV_INDEX, self._update_uv_index),
            (CONF_VISIBILITY, self._update_visibility),
            (CONF_WIND_BEARING, self._update_wind_bearing),
            (CONF_WIND_GUST_SPEED, self._update_wind_gust_speed),
            (CONF_WIND_SPEED, self._update_wind_speed),
        ):
            if (rendered := self._rendered.get(key)) is not None:
                updater(rendered)
                write_ha_state = True

        if write_ha_state:
            self.async_write_ha_state()

    async def async_forecast_daily(self) -> list[Forecast]:
        """Return the daily forecast in native units."""
        return (
            self._validate_forecast("daily", self._rendered.get(CONF_FORECAST_DAILY))
            or []
        )

    async def async_forecast_hourly(self) -> list[Forecast]:
        """Return the daily forecast in native units."""
        return (
            self._validate_forecast("hourly", self._rendered.get(CONF_FORECAST_HOURLY))
            or []
        )

    async def async_forecast_twice_daily(self) -> list[Forecast]:
        """Return the daily forecast in native units."""
        return (
            self._validate_forecast(
                "twice_daily", self._rendered.get(CONF_FORECAST_TWICE_DAILY)
            )
            or []
        )

    @property
    def extra_restore_state_data(self) -> WeatherExtraStoredData:
        """Return weather specific state data to be restored."""
        return WeatherExtraStoredData(
            last_apparent_temperature=self._rendered.get(CONF_APPARENT_TEMPERATURE),
            last_cloud_coverage=self._rendered.get(CONF_CLOUD_COVERAGE),
            last_dew_point=self._rendered.get(CONF_DEW_POINT),
            last_humidity=self._rendered.get(CONF_HUMIDITY),
            last_ozone=self._rendered.get(CONF_OZONE),
            last_pressure=self._rendered.get(CONF_PRESSURE),
            last_temperature=self._rendered.get(CONF_TEMPERATURE),
            last_uv_index=self._rendered.get(CONF_UV_INDEX),
            last_visibility=self._rendered.get(CONF_VISIBILITY),
            last_wind_bearing=self._rendered.get(CONF_WIND_BEARING),
            last_wind_gust_speed=self._rendered.get(CONF_WIND_GUST_SPEED),
            last_wind_speed=self._rendered.get(CONF_WIND_SPEED),
        )

    async def async_get_last_weather_data(self) -> WeatherExtraStoredData | None:
        """Restore weather specific state data."""
        if (restored_last_extra_data := await self.async_get_last_extra_data()) is None:
            return None
        return WeatherExtraStoredData.from_dict(restored_last_extra_data.as_dict())