Add support for minutely forecasts

Author: joelhawksley

homeassistant/components/weather/__init__.py

@@ -1,5 +1,7 @@
 """Weather component that handles meteorological data for your location."""
 
+from __future__ import annotations
+
 import abc
 from collections.abc import Callable, Iterable
 from contextlib import suppress
@@ -152,6 +154,11 @@
     bound=TimestampDataUpdateCoordinator[Any],
     default=_DailyForecastUpdateCoordinatorT,
 )
+_MinutelyForecastUpdateCoordinatorT = TypeVar(
+    "_MinutelyForecastUpdateCoordinatorT",
+    bound=TimestampDataUpdateCoordinator[Any],
+    default=_DailyForecastUpdateCoordinatorT,
+)
 
 # mypy: disallow-any-generics
 
@@ -210,12 +217,13 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     )
     component.async_register_entity_service(
         SERVICE_GET_FORECASTS,
-        {vol.Required("type"): vol.In(("daily", "hourly", "twice_daily"))},
+        {vol.Required("type"): vol.In(("daily", "hourly", "twice_daily", "minutely"))},
         async_get_forecasts_service,
         required_features=[
             WeatherEntityFeature.FORECAST_DAILY,
             WeatherEntityFeature.FORECAST_HOURLY,
             WeatherEntityFeature.FORECAST_TWICE_DAILY,
+            WeatherEntityFeature.FORECAST_MINUTELY,
         ],
         supports_response=SupportsResponse.ONLY,
     )
@@ -305,7 +313,7 @@ class WeatherEntity(Entity, PostInit, cached_properties=CACHED_PROPERTIES_WITH_A
     _attr_native_dew_point: float | None = None
 
     _forecast_listeners: dict[
-        Literal["daily", "hourly", "twice_daily"],
+        Literal["daily", "hourly", "twice_daily", "minutely"],
         list[Callable[[list[JsonValueType] | None], None]],
     ]
 
@@ -317,7 +325,12 @@ class WeatherEntity(Entity, PostInit, cached_properties=CACHED_PROPERTIES_WITH_A
 
     def __post_init__(self, *args: Any, **kwargs: Any) -> None:
         """Finish initializing."""
-        self._forecast_listeners = {"daily": [], "hourly": [], "twice_daily": []}
+        self._forecast_listeners = {
+            "daily": [],
+            "hourly": [],
+            "twice_daily": [],
+            "minutely": [],
+        }
 
     async def async_internal_added_to_hass(self) -> None:
         """Call when the weather entity is added to hass."""
@@ -514,6 +527,10 @@ async def async_forecast_hourly(self) -> list[Forecast] | None:
         """Return the hourly forecast in native units."""
         raise NotImplementedError
 
+    async def async_forecast_minutely(self) -> list[Forecast] | None:
+        """Return the minutely forecast in native units."""
+        raise NotImplementedError
+
     @cached_property
     def native_precipitation_unit(self) -> str | None:
         """Return the native unit of measurement for accumulated precipitation."""
@@ -927,22 +944,22 @@ def async_registry_entry_updated(self) -> None:
     @callback
     def _async_subscription_started(
         self,
-        forecast_type: Literal["daily", "hourly", "twice_daily"],
+        forecast_type: Literal["daily", "hourly", "twice_daily", "minutely"],
     ) -> None:
         """Start subscription to forecast_type."""
 
     @callback
     def _async_subscription_ended(
         self,
-        forecast_type: Literal["daily", "hourly", "twice_daily"],
+        forecast_type: Literal["daily", "hourly", "twice_daily", "minutely"],
     ) -> None:
         """End subscription to forecast_type."""
 
     @final
     @callback
     def async_subscribe_forecast(
         self,
-        forecast_type: Literal["daily", "hourly", "twice_daily"],
+        forecast_type: Literal["daily", "hourly", "twice_daily", "minutely"],
         forecast_listener: Callable[[list[JsonValueType] | None], None],
     ) -> CALLBACK_TYPE:
         """Subscribe to forecast updates.
@@ -964,11 +981,13 @@ def unsubscribe() -> None:
 
     @final
     async def async_update_listeners(
-        self, forecast_types: Iterable[Literal["daily", "hourly", "twice_daily"]] | None
+        self,
+        forecast_types: Iterable[Literal["daily", "hourly", "twice_daily", "minutely"]]
+        | None,
     ) -> None:
         """Push updated forecast to all listeners."""
         if forecast_types is None:
-            forecast_types = {"daily", "hourly", "twice_daily"}
+            forecast_types = {"daily", "hourly", "twice_daily", "minutely"}
         for forecast_type in forecast_types:
             if not self._forecast_listeners[forecast_type]:
                 continue
@@ -1015,6 +1034,10 @@ async def async_get_forecasts_service(
         if (supported_features & WeatherEntityFeature.FORECAST_HOURLY) == 0:
             raise_unsupported_forecast(weather.entity_id, forecast_type)
         native_forecast_list = await weather.async_forecast_hourly()
+    elif forecast_type == "minutely":
+        if (supported_features & WeatherEntityFeature.FORECAST_MINUTELY) == 0:
+            raise_unsupported_forecast(weather.entity_id, forecast_type)
+        native_forecast_list = await weather.async_forecast_minutely()
     else:
         if (supported_features & WeatherEntityFeature.FORECAST_TWICE_DAILY) == 0:
             raise_unsupported_forecast(weather.entity_id, forecast_type)
@@ -1036,6 +1059,7 @@ class CoordinatorWeatherEntity(
         _DailyForecastUpdateCoordinatorT,
         _HourlyForecastUpdateCoordinatorT,
         _TwiceDailyForecastUpdateCoordinatorT,
+        _MinutelyForecastUpdateCoordinatorT,
     ],
 ):
     """A class for weather entities using DataUpdateCoordinators."""
@@ -1048,26 +1072,31 @@ def __init__(
         daily_coordinator: _DailyForecastUpdateCoordinatorT | None = None,
         hourly_coordinator: _HourlyForecastUpdateCoordinatorT | None = None,
         twice_daily_coordinator: _TwiceDailyForecastUpdateCoordinatorT | None = None,
+        minutely_coordinator: _MinutelyForecastUpdateCoordinatorT | None = None,
         daily_forecast_valid: timedelta | None = None,
         hourly_forecast_valid: timedelta | None = None,
         twice_daily_forecast_valid: timedelta | None = None,
+        minutely_forecast_valid: timedelta | None = None,
     ) -> None:
         """Initialize."""
         super().__init__(observation_coordinator, context)
         self.forecast_coordinators = {
             "daily": daily_coordinator,
             "hourly": hourly_coordinator,
             "twice_daily": twice_daily_coordinator,
+            "minutely": minutely_coordinator,
         }
         self.forecast_valid = {
             "daily": daily_forecast_valid,
             "hourly": hourly_forecast_valid,
             "twice_daily": twice_daily_forecast_valid,
+            "minutely": minutely_forecast_valid,
         }
         self.unsub_forecast: dict[str, Callable[[], None] | None] = {
             "daily": None,
             "hourly": None,
             "twice_daily": None,
+            "minutely": None,
         }
 
     async def async_added_to_hass(self) -> None:
@@ -1076,9 +1105,10 @@ async def async_added_to_hass(self) -> None:
         self.async_on_remove(partial(self._remove_forecast_listener, "daily"))
         self.async_on_remove(partial(self._remove_forecast_listener, "hourly"))
         self.async_on_remove(partial(self._remove_forecast_listener, "twice_daily"))
+        self.async_on_remove(partial(self._remove_forecast_listener, "minutely"))
 
     def _remove_forecast_listener(
-        self, forecast_type: Literal["daily", "hourly", "twice_daily"]
+        self, forecast_type: Literal["daily", "hourly", "twice_daily", "minutely"]
     ) -> None:
         """Remove weather forecast listener."""
         if unsub_fn := self.unsub_forecast[forecast_type]:
@@ -1088,7 +1118,7 @@ def _remove_forecast_listener(
     @callback
     def _async_subscription_started(
         self,
-        forecast_type: Literal["daily", "hourly", "twice_daily"],
+        forecast_type: Literal["daily", "hourly", "twice_daily", "minutely"],
     ) -> None:
         """Start subscription to forecast_type."""
         if not (coordinator := self.forecast_coordinators[forecast_type]):
@@ -1109,10 +1139,14 @@ def _handle_hourly_forecast_coordinator_update(self) -> None:
     def _handle_twice_daily_forecast_coordinator_update(self) -> None:
         """Handle updated data from the twice daily forecast coordinator."""
 
+    @callback
+    def _handle_minutely_forecast_coordinator_update(self) -> None:
+        """Handle updated data from the minutely forecast coordinator."""
+
     @final
     @callback
     def _handle_forecast_update(
-        self, forecast_type: Literal["daily", "hourly", "twice_daily"]
+        self, forecast_type: Literal["daily", "hourly", "twice_daily", "minutely"]
     ) -> None:
         """Update forecast data."""
         coordinator = self.forecast_coordinators[forecast_type]
@@ -1126,7 +1160,7 @@ def _handle_forecast_update(
     @callback
     def _async_subscription_ended(
         self,
-        forecast_type: Literal["daily", "hourly", "twice_daily"],
+        forecast_type: Literal["daily", "hourly", "twice_daily", "minutely"],
     ) -> None:
         """End subscription to forecast_type."""
         self._remove_forecast_listener(forecast_type)
@@ -1169,9 +1203,14 @@ def _async_forecast_twice_daily(self) -> list[Forecast] | None:
         """Return the twice daily forecast in native units."""
         raise NotImplementedError
 
+    @callback
+    def _async_forecast_minutely(self) -> list[Forecast] | None:
+        """Return the minutely forecast in native units."""
+        raise NotImplementedError
+
     @final
     async def _async_forecast(
-        self, forecast_type: Literal["daily", "hourly", "twice_daily"]
+        self, forecast_type: Literal["daily", "hourly", "twice_daily", "minutely"]
     ) -> list[Forecast] | None:
         """Return the forecast in native units."""
         coordinator = self.forecast_coordinators[forecast_type]
@@ -1198,6 +1237,11 @@ async def async_forecast_twice_daily(self) -> list[Forecast] | None:
         """Return the twice daily forecast in native units."""
         return await self._async_forecast("twice_daily")
 
+    @final
+    async def async_forecast_minutely(self) -> list[Forecast] | None:
+        """Return the minutely forecast in native units."""
+        return await self._async_forecast("minutely")
+
 
 class SingleCoordinatorWeatherEntity(
     CoordinatorWeatherEntity[

homeassistant/components/weather/const.py

@@ -1,5 +1,7 @@
 """Constants for weather."""
 
+from __future__ import annotations
+
 from collections.abc import Callable
 from enum import IntFlag
 from typing import TYPE_CHECKING, Final
@@ -31,6 +33,7 @@ class WeatherEntityFeature(IntFlag):
     FORECAST_DAILY = 1
     FORECAST_HOURLY = 2
     FORECAST_TWICE_DAILY = 4
+    FORECAST_MINUTELY = 8
 
 
 ATTR_WEATHER_HUMIDITY = "humidity"

homeassistant/components/weather/services.yaml

@@ -6,6 +6,7 @@ get_forecast:
         - weather.WeatherEntityFeature.FORECAST_DAILY
         - weather.WeatherEntityFeature.FORECAST_HOURLY
         - weather.WeatherEntityFeature.FORECAST_TWICE_DAILY
+        - weather.WeatherEntityFeature.FORECAST_MINUTELY
   fields:
     type:
       required: true
@@ -15,6 +16,7 @@ get_forecast:
             - "daily"
             - "hourly"
             - "twice_daily"
+            - "minutely"
           translation_key: forecast_type
 get_forecasts:
   target:
@@ -24,6 +26,7 @@ get_forecasts:
         - weather.WeatherEntityFeature.FORECAST_DAILY
         - weather.WeatherEntityFeature.FORECAST_HOURLY
         - weather.WeatherEntityFeature.FORECAST_TWICE_DAILY
+        - weather.WeatherEntityFeature.FORECAST_MINUTELY
   fields:
     type:
       required: true
@@ -33,4 +36,5 @@ get_forecasts:
             - "daily"
             - "hourly"
             - "twice_daily"
+            - "minutely"
           translation_key: forecast_type

homeassistant/components/weather/strings.json

@@ -95,6 +95,7 @@
       "options": {
         "daily": "Daily",
         "hourly": "Hourly",
+        "minutely": "Minutely",
         "twice_daily": "Twice daily"
       }
     }

homeassistant/components/weather/websocket_api.py

@@ -1,5 +1,7 @@
 """The weather websocket API."""
 
+from __future__ import annotations
+
 from typing import Any, Literal
 
 import voluptuous as vol

homeassistant/components/weatherkit/const.py

@@ -19,5 +19,6 @@
 CONF_KEY_PEM = "key_pem"
 
 ATTR_CURRENT_WEATHER = "currentWeather"
+ATTR_FORECAST_NEXT_HOUR = "forecastNextHour"
 ATTR_FORECAST_HOURLY = "forecastHourly"
 ATTR_FORECAST_DAILY = "forecastDaily"

homeassistant/components/weatherkit/coordinator.py

@@ -1,5 +1,7 @@
 """DataUpdateCoordinator for WeatherKit integration."""
 
+from __future__ import annotations
+
 from datetime import datetime, timedelta
 
 from apple_weatherkit import DataSetType
@@ -17,6 +19,7 @@
     DataSetType.CURRENT_WEATHER,
     DataSetType.DAILY_FORECAST,
     DataSetType.HOURLY_FORECAST,
+    DataSetType.NEXT_HOUR_FORECAST,
 ]
 
 STALE_DATA_THRESHOLD = timedelta(hours=1)

homeassistant/components/weatherkit/weather.py

@@ -34,6 +34,7 @@
     ATTR_CURRENT_WEATHER,
     ATTR_FORECAST_DAILY,
     ATTR_FORECAST_HOURLY,
+    ATTR_FORECAST_NEXT_HOUR,
     ATTRIBUTION,
 )
 from .coordinator import WeatherKitConfigEntry, WeatherKitDataUpdateCoordinator
@@ -118,6 +119,16 @@ def _map_hourly_forecast(forecast: dict[str, Any]) -> Forecast:
     }
 
 
+def _map_next_hour_forecast(forecast: dict[str, Any]) -> Forecast:
+    precipitation_intensity = forecast.get("precipitationIntensity")
+
+    return {
+        "datetime": forecast["startTime"],
+        "native_precipitation": precipitation_intensity,
+        "precipitation_probability": forecast["precipitationChance"] * 100,
+    }
+
+
 class WeatherKitWeather(
     SingleCoordinatorWeatherEntity[WeatherKitDataUpdateCoordinator], WeatherKitEntity
 ):
@@ -153,6 +164,8 @@ def supported_features(self) -> WeatherEntityFeature:
             features |= WeatherEntityFeature.FORECAST_DAILY
         if DataSetType.HOURLY_FORECAST in self.coordinator.supported_data_sets:
             features |= WeatherEntityFeature.FORECAST_HOURLY
+        if DataSetType.NEXT_HOUR_FORECAST in self.coordinator.supported_data_sets:
+            features |= WeatherEntityFeature.FORECAST_MINUTELY
         return features
 
     @property
@@ -250,3 +263,15 @@ def _async_forecast_hourly(self) -> list[Forecast] | None:
 
         forecast = hourly_forecast.get("hours")
         return [_map_hourly_forecast(f) for f in forecast]
+
+    @callback
+    def _async_forecast_minutely(self) -> list[Forecast] | None:
+        """Return the minutely forecast."""
+        minutely_forecast = self.data.get(ATTR_FORECAST_NEXT_HOUR)
+        if not minutely_forecast:
+            return None
+
+        forecast = minutely_forecast.get("minutes")
+        if forecast is None:
+            return None
+        return [_map_next_hour_forecast(f) for f in forecast]

tests/components/weather/snapshots/test_init.ambr

@@ -29,6 +29,21 @@
     }),
   })
 # ---
+# name: test_get_forecast[minutely-8]
+  dict({
+    'weather.testing': dict({
+      'forecast': list([
+        dict({
+          'cloud_coverage': None,
+          'temperature': 38.0,
+          'templow': 38.0,
+          'uv_index': None,
+          'wind_bearing': None,
+        }),
+      ]),
+    }),
+  })
+# ---
 # name: test_get_forecast[twice_daily-4]
   dict({
     'weather.testing': dict({