Add new integration here_weather

CODEOWNERS

@@ -205,6 +205,7 @@ homeassistant/components/hassio/* @home-assistant/supervisor
 homeassistant/components/heatmiser/* @andylockran
 homeassistant/components/heos/* @andrewsayre
 homeassistant/components/here_travel_time/* @eifinger
+homeassistant/components/here_weather/* @eifinger
 homeassistant/components/hikvision/* @mezz64
 homeassistant/components/hikvisioncam/* @fbradyirl
 homeassistant/components/hisense_aehw4a1/* @bannhead

homeassistant/components/here_travel_time/manifest.json

@@ -2,7 +2,7 @@
   "domain": "here_travel_time",
   "name": "HERE Travel Time",
   "documentation": "https://www.home-assistant.io/integrations/here_travel_time",
-  "requirements": ["herepy==2.0.0"],
+  "requirements": ["herepy==3.5.3"],
   "codeowners": ["@eifinger"],
   "iot_class": "cloud_polling"
 }

homeassistant/components/here_weather/__init__.py

@@ -0,0 +1,129 @@
+"""The here_weather component."""
+from __future__ import annotations
+
+from datetime import timedelta
+import logging
+
+import async_timeout
+import herepy
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import (
+    CONF_API_KEY,
+    CONF_LATITUDE,
+    CONF_LONGITUDE,
+    CONF_UNIT_SYSTEM_METRIC,
+)
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+
+from .const import (
+    CONF_MODES,
+    DEFAULT_SCAN_INTERVAL,
+    DOMAIN,
+    MAX_UPDATE_RATE_FOR_ONE_CLIENT,
+)
+from .utils import active_here_clients
+
+_LOGGER = logging.getLogger(__name__)
+
+PLATFORMS = ["sensor", "weather"]
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+    """Set up here_weather from a config entry."""
+    here_weather_coordinators = {}
+    for mode in CONF_MODES:
+        coordinator = HEREWeatherDataUpdateCoordinator(hass, entry, mode)
+        await coordinator.async_config_entry_first_refresh()
+        here_weather_coordinators[mode] = coordinator
+    hass.data.setdefault(DOMAIN, {})[entry.entry_id] = here_weather_coordinators
+
+    hass.config_entries.async_setup_platforms(entry, PLATFORMS)
+
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+    """Unload a config entry."""
+    unload_ok = await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
+    if unload_ok:
+        hass.data[DOMAIN].pop(entry.entry_id)
+
+    return unload_ok
+
+
+class HEREWeatherDataUpdateCoordinator(DataUpdateCoordinator):
+    """Get the latest data from HERE."""
+
+    def __init__(self, hass: HomeAssistant, entry: ConfigEntry, mode: str) -> None:
+        """Initialize the data object."""
+        self.here_client = herepy.DestinationWeatherApi(entry.data[CONF_API_KEY])
+        self.latitude = entry.data[CONF_LATITUDE]
+        self.longitude = entry.data[CONF_LONGITUDE]
+        self.weather_product_type = herepy.WeatherProductType[mode]
+
+        super().__init__(
+            hass,
+            _LOGGER,
+            name=DOMAIN,
+            update_interval=timedelta(seconds=DEFAULT_SCAN_INTERVAL),
+        )
+
+    def number_of_listeners(self) -> int:
+        """Return the number ob active listeners registered against this coordinator."""
+        return len(self._listeners)
+
+    async def _async_update_data(self) -> list:
+        """Perform data update."""
+        try:
+            async with async_timeout.timeout(10):
+                data = await self.hass.async_add_executor_job(self._get_data)
+                self._set_update_interval()
+                return data
+        except herepy.InvalidRequestError as error:
+            raise UpdateFailed(
+                f"Unable to fetch data from HERE: {error.message}"
+            ) from error
+
+    def _get_data(self):
+        """Get the latest data from HERE."""
+        is_metric = self.hass.config.units.name == CONF_UNIT_SYSTEM_METRIC
+        data = self.here_client.weather_for_coordinates(
+            self.latitude,
+            self.longitude,
+            self.weather_product_type,
+            metric=is_metric,
+        )
+        return extract_data_from_payload_for_product_type(
+            data, self.weather_product_type
+        )
+
+    def _set_update_interval(self) -> int:
+        """Throttle the default update rate based on the number of active clients."""
+        if (
+            update_interval := (
+                active_here_clients(self.hass) * MAX_UPDATE_RATE_FOR_ONE_CLIENT * 2
+            )
+        ) > DEFAULT_SCAN_INTERVAL:
+            _LOGGER.debug("Setting update_interval to %s", update_interval)
+            return update_interval
+        return DEFAULT_SCAN_INTERVAL
+
+
+def extract_data_from_payload_for_product_type(
+    data: herepy.DestinationWeatherResponse, product_type: herepy.WeatherProductType
+) -> list:
+    """Extract the actual data from the HERE payload."""
+    if product_type == herepy.WeatherProductType.forecast_astronomy:
+        return data.astronomy["astronomy"]
+    if product_type == herepy.WeatherProductType.observation:
+        return data.observations["location"][0]["observation"]
+    if product_type == herepy.WeatherProductType.forecast_7days:
+        return data.forecasts["forecastLocation"]["forecast"]
+    if product_type == herepy.WeatherProductType.forecast_7days_simple:
+        return data.dailyForecasts["forecastLocation"]["forecast"]
+    if product_type == herepy.WeatherProductType.forecast_hourly:
+        return data.hourlyForecasts["forecastLocation"]["forecast"]
+    _LOGGER.debug("Payload malformed: %s", data)
+    raise UpdateFailed("Payload malformed")

homeassistant/components/here_weather/config_flow.py

@@ -0,0 +1,87 @@
+"""Config flow for here_weather integration."""
+from __future__ import annotations
+
+import herepy
+import voluptuous as vol
+
+from homeassistant import config_entries
+from homeassistant.const import CONF_API_KEY, CONF_LATITUDE, CONF_LONGITUDE, CONF_NAME
+from homeassistant.core import HomeAssistant
+import homeassistant.helpers.config_validation as cv
+
+from .const import DEFAULT_MODE, DOMAIN
+
+
+async def async_validate_user_input(hass: HomeAssistant, user_input: dict) -> None:
+    """Validate the user_input containing coordinates."""
+    here_client = herepy.DestinationWeatherApi(user_input[CONF_API_KEY])
+    await hass.async_add_executor_job(
+        here_client.weather_for_coordinates,
+        user_input[CONF_LATITUDE],
+        user_input[CONF_LONGITUDE],
+        herepy.WeatherProductType[DEFAULT_MODE],
+    )
+
+
+class HereWeatherConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for here_weather."""
+
+    VERSION = 1
+
+    async def async_step_user(self, user_input=None):
+        """Handle the initial step."""
+        errors = {}
+        if user_input is not None:
+            await self.async_set_unique_id(_unique_id(user_input))
+            self._abort_if_unique_id_configured()
+            try:
+                await async_validate_user_input(self.hass, user_input)
+            except herepy.InvalidRequestError:
+                errors["base"] = "invalid_request"
+            except herepy.UnauthorizedError:
+                errors["base"] = "unauthorized"
+            else:
+                return self.async_create_entry(
+                    title=user_input[CONF_NAME], data=user_input
+                )
+        return self.async_show_form(
+            step_id="user",
+            data_schema=self._get_schema(user_input),
+            errors=errors,
+        )
+
+    def _get_schema(self, user_input: dict | None) -> vol.Schema:
+        known_api_keys = {
+            entry.data[CONF_API_KEY] for entry in self._async_current_entries()
+        }
+        if user_input is not None:
+            return vol.Schema(
+                {
+                    vol.Required(
+                        CONF_API_KEY, default=user_input[CONF_API_KEY]
+                    ): vol.In(known_api_keys),
+                    vol.Required(CONF_NAME, default=user_input[CONF_NAME]): str,
+                    vol.Required(
+                        CONF_LATITUDE, default=user_input[CONF_LATITUDE]
+                    ): cv.latitude,
+                    vol.Required(
+                        CONF_LONGITUDE, default=user_input[CONF_LONGITUDE]
+                    ): cv.longitude,
+                }
+            )
+        return vol.Schema(
+            {
+                vol.Required(CONF_API_KEY): vol.In(known_api_keys),
+                vol.Required(CONF_NAME, default=DOMAIN): str,
+                vol.Required(
+                    CONF_LATITUDE, default=self.hass.config.latitude
+                ): cv.latitude,
+                vol.Required(
+                    CONF_LONGITUDE, default=self.hass.config.longitude
+                ): cv.longitude,
+            }
+        )
+
+
+def _unique_id(user_input: dict) -> str:
+    return f"{user_input[CONF_LATITUDE]}_{user_input[CONF_LONGITUDE]}"