Migrate OpenWeaterMap to new library (support API 3.0)

homeassistant/components/openweathermap/__init__.py

@@ -5,8 +5,7 @@
 import logging
 from typing import Any
 
-from pyowm import OWM
-from pyowm.utils.config import get_default_config
+from pyopenweathermap import OWMClient
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
@@ -40,14 +39,11 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     api_key = entry.data[CONF_API_KEY]
     latitude = entry.data.get(CONF_LATITUDE, hass.config.latitude)
     longitude = entry.data.get(CONF_LONGITUDE, hass.config.longitude)
-    forecast_mode = _get_config_value(entry, CONF_MODE)
     language = _get_config_value(entry, CONF_LANGUAGE)
 
-    config_dict = _get_owm_config(language)
-
-    owm = OWM(api_key, config_dict).weather_manager()
+    owm_client = OWMClient(api_key, lang=language)
     weather_coordinator = WeatherUpdateCoordinator(
-        owm, latitude, longitude, forecast_mode, hass
+        owm_client, latitude, longitude, hass
     )
 
     await weather_coordinator.async_config_entry_first_refresh()
@@ -108,10 +104,3 @@ def _get_config_value(config_entry: ConfigEntry, key: str) -> Any:
     if config_entry.options:
         return config_entry.options[key]
     return config_entry.data[key]
-
-
-def _get_owm_config(language: str) -> dict[str, Any]:
-    """Get OpenWeatherMap configuration and add language to it."""
-    config_dict = get_default_config()
-    config_dict["language"] = language
-    return config_dict

homeassistant/components/openweathermap/config_flow.py

@@ -2,29 +2,30 @@
 
 from __future__ import annotations
 
-from pyowm import OWM
-from pyowm.commons.exceptions import APIRequestError, UnauthorizedError
+from pyopenweathermap import OWMClient, RequestError
 import voluptuous as vol
 
-from homeassistant.config_entries import ConfigEntry, ConfigFlow, OptionsFlow
+from homeassistant.config_entries import (
+    ConfigEntry,
+    ConfigFlow,
+    ConfigFlowResult,
+    OptionsFlow,
+)
 from homeassistant.const import (
     CONF_API_KEY,
     CONF_LANGUAGE,
     CONF_LATITUDE,
     CONF_LONGITUDE,
-    CONF_MODE,
     CONF_NAME,
 )
 from homeassistant.core import callback
 import homeassistant.helpers.config_validation as cv
 
 from .const import (
     CONFIG_FLOW_VERSION,
-    DEFAULT_FORECAST_MODE,
     DEFAULT_LANGUAGE,
     DEFAULT_NAME,
     DOMAIN,
-    FORECAST_MODES,
     LANGUAGES,
 )
 
@@ -42,7 +43,7 @@ def async_get_options_flow(
         """Get the options flow for this handler."""
         return OpenWeatherMapOptionsFlow(config_entry)
 
-    async def async_step_user(self, user_input=None):
+    async def async_step_user(self, user_input=None) -> ConfigFlowResult:
         """Handle a flow initialized by the user."""
         errors = {}
 
@@ -54,14 +55,10 @@ async def async_step_user(self, user_input=None):
             self._abort_if_unique_id_configured()
 
             try:
-                api_online = await _is_owm_api_online(
-                    self.hass, user_input[CONF_API_KEY], latitude, longitude
-                )
-                if not api_online:
+                api_key_valid = await _is_owm_api_key_valid(user_input[CONF_API_KEY])
+                if api_key_valid is False:
                     errors["base"] = "invalid_api_key"
-            except UnauthorizedError:
-                errors["base"] = "invalid_api_key"
-            except APIRequestError:
+            except RequestError:
                 errors["base"] = "cannot_connect"
 
             if not errors:
@@ -79,9 +76,6 @@ async def async_step_user(self, user_input=None):
                 vol.Optional(
                     CONF_LONGITUDE, default=self.hass.config.longitude
                 ): cv.longitude,
-                vol.Optional(CONF_MODE, default=DEFAULT_FORECAST_MODE): vol.In(
-                    FORECAST_MODES
-                ),
                 vol.Optional(CONF_LANGUAGE, default=DEFAULT_LANGUAGE): vol.In(
                     LANGUAGES
                 ),
@@ -98,7 +92,7 @@ def __init__(self, config_entry: ConfigEntry) -> None:
         """Initialize options flow."""
         self.config_entry = config_entry
 
-    async def async_step_init(self, user_input=None):
+    async def async_step_init(self, user_input=None) -> ConfigFlowResult:
         """Manage the options."""
         if user_input is not None:
             return self.async_create_entry(title="", data=user_input)
@@ -111,13 +105,6 @@ async def async_step_init(self, user_input=None):
     def _get_options_schema(self):
         return vol.Schema(
             {
-                vol.Optional(
-                    CONF_MODE,
-                    default=self.config_entry.options.get(
-                        CONF_MODE,
-                        self.config_entry.data.get(CONF_MODE, DEFAULT_FORECAST_MODE),
-                    ),
-                ): vol.In(FORECAST_MODES),
                 vol.Optional(
                     CONF_LANGUAGE,
                     default=self.config_entry.options.get(
@@ -129,6 +116,6 @@ def _get_options_schema(self):
         )
 
 
-async def _is_owm_api_online(hass, api_key, lat, lon):
-    owm = OWM(api_key).weather_manager()
-    return await hass.async_add_executor_job(owm.weather_at_coords, lat, lon)
+async def _is_owm_api_key_valid(api_key):
+    owm_client = OWMClient(api_key)
+    return await owm_client.validate_key()

homeassistant/components/openweathermap/const.py

@@ -47,7 +47,11 @@
 ATTR_API_UV_INDEX = "uv_index"
 ATTR_API_VISIBILITY_DISTANCE = "visibility_distance"
 ATTR_API_WEATHER_CODE = "weather_code"
+ATTR_API_CLOUD_COVERAGE = "cloud_coverage"
 ATTR_API_FORECAST = "forecast"
+ATTR_API_CURRENT = "current"
+ATTR_API_HOURLY_FORECAST = "hourly_forecast"
+ATTR_API_DAILY_FORECAST = "daily_forecast"
 UPDATE_LISTENER = "update_listener"
 PLATFORMS = [Platform.SENSOR, Platform.WEATHER]
 

homeassistant/components/openweathermap/manifest.json

@@ -5,6 +5,6 @@
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/openweathermap",
   "iot_class": "cloud_polling",
-  "loggers": ["geojson", "pyowm", "pysocks"],
-  "requirements": ["pyowm==3.2.0"]
+  "loggers": ["geojson", "pyopenweathermap", "pysocks"],
+  "requirements": ["pyopenweathermap==0.0.5"]
 }

homeassistant/components/openweathermap/sensor.py

@@ -30,12 +30,13 @@
 from homeassistant.util import dt as dt_util
 
 from .const import (
+    ATTR_API_CLOUD_COVERAGE,
     ATTR_API_CLOUDS,
     ATTR_API_CONDITION,
+    ATTR_API_CURRENT,
+    ATTR_API_DAILY_FORECAST,
     ATTR_API_DEW_POINT,
     ATTR_API_FEELS_LIKE_TEMPERATURE,
-    ATTR_API_FORECAST,
-    ATTR_API_FORECAST_CONDITION,
     ATTR_API_FORECAST_PRECIPITATION,
     ATTR_API_FORECAST_PRECIPITATION_PROBABILITY,
     ATTR_API_FORECAST_PRESSURE,
@@ -164,7 +165,7 @@
 )
 FORECAST_SENSOR_TYPES: tuple[SensorEntityDescription, ...] = (
     SensorEntityDescription(
-        key=ATTR_API_FORECAST_CONDITION,
+        key=ATTR_API_CONDITION,
         name="Condition",
     ),
     SensorEntityDescription(
@@ -213,7 +214,7 @@
         device_class=SensorDeviceClass.WIND_SPEED,
     ),
     SensorEntityDescription(
-        key=ATTR_API_CLOUDS,
+        key=ATTR_API_CLOUD_COVERAGE,
         name="Cloud coverage",
         native_unit_of_measurement=PERCENTAGE,
     ),
@@ -315,7 +316,9 @@ def __init__(
     @property
     def native_value(self) -> StateType:
         """Return the state of the device."""
-        return self._weather_coordinator.data.get(self.entity_description.key, None)
+        return self._weather_coordinator.data[ATTR_API_CURRENT].get(
+            self.entity_description.key, None
+        )
 
 
 class OpenWeatherMapForecastSensor(AbstractOpenWeatherMapSensor):
@@ -335,10 +338,7 @@ def __init__(
     @property
     def native_value(self) -> StateType | datetime:
         """Return the state of the device."""
-        forecasts = self._weather_coordinator.data.get(ATTR_API_FORECAST)
-        if not forecasts:
-            return None
-
+        forecasts = self._weather_coordinator.data[ATTR_API_DAILY_FORECAST]
         value = forecasts[0].get(self.entity_description.key, None)
         if (
             value

homeassistant/components/openweathermap/weather.py

@@ -2,21 +2,7 @@
 
 from __future__ import annotations
 
-from typing import cast
-
 from homeassistant.components.weather import (
-    ATTR_FORECAST_CLOUD_COVERAGE,
-    ATTR_FORECAST_CONDITION,
-    ATTR_FORECAST_HUMIDITY,
-    ATTR_FORECAST_NATIVE_APPARENT_TEMP,
-    ATTR_FORECAST_NATIVE_PRECIPITATION,
-    ATTR_FORECAST_NATIVE_PRESSURE,
-    ATTR_FORECAST_NATIVE_TEMP,
-    ATTR_FORECAST_NATIVE_TEMP_LOW,
-    ATTR_FORECAST_NATIVE_WIND_SPEED,
-    ATTR_FORECAST_PRECIPITATION_PROBABILITY,
-    ATTR_FORECAST_TIME,
-    ATTR_FORECAST_WIND_BEARING,
     Forecast,
     SingleCoordinatorWeatherEntity,
     WeatherEntityFeature,
@@ -35,21 +21,11 @@
 from .const import (
     ATTR_API_CLOUDS,
     ATTR_API_CONDITION,
+    ATTR_API_CURRENT,
+    ATTR_API_DAILY_FORECAST,
     ATTR_API_DEW_POINT,
     ATTR_API_FEELS_LIKE_TEMPERATURE,
-    ATTR_API_FORECAST,
-    ATTR_API_FORECAST_CLOUDS,
-    ATTR_API_FORECAST_CONDITION,
-    ATTR_API_FORECAST_FEELS_LIKE_TEMPERATURE,
-    ATTR_API_FORECAST_HUMIDITY,
-    ATTR_API_FORECAST_PRECIPITATION,
-    ATTR_API_FORECAST_PRECIPITATION_PROBABILITY,
-    ATTR_API_FORECAST_PRESSURE,
-    ATTR_API_FORECAST_TEMP,
-    ATTR_API_FORECAST_TEMP_LOW,
-    ATTR_API_FORECAST_TIME,
-    ATTR_API_FORECAST_WIND_BEARING,
-    ATTR_API_FORECAST_WIND_SPEED,
+    ATTR_API_HOURLY_FORECAST,
     ATTR_API_HUMIDITY,
     ATTR_API_PRESSURE,
     ATTR_API_TEMPERATURE,
@@ -61,27 +37,10 @@
     DOMAIN,
     ENTRY_NAME,
     ENTRY_WEATHER_COORDINATOR,
-    FORECAST_MODE_DAILY,
-    FORECAST_MODE_ONECALL_DAILY,
     MANUFACTURER,
 )
 from .weather_update_coordinator import WeatherUpdateCoordinator
 
-FORECAST_MAP = {
-    ATTR_API_FORECAST_CONDITION: ATTR_FORECAST_CONDITION,
-    ATTR_API_FORECAST_PRECIPITATION: ATTR_FORECAST_NATIVE_PRECIPITATION,
-    ATTR_API_FORECAST_PRECIPITATION_PROBABILITY: ATTR_FORECAST_PRECIPITATION_PROBABILITY,
-    ATTR_API_FORECAST_PRESSURE: ATTR_FORECAST_NATIVE_PRESSURE,
-    ATTR_API_FORECAST_TEMP_LOW: ATTR_FORECAST_NATIVE_TEMP_LOW,
-    ATTR_API_FORECAST_TEMP: ATTR_FORECAST_NATIVE_TEMP,
-    ATTR_API_FORECAST_TIME: ATTR_FORECAST_TIME,
-    ATTR_API_FORECAST_WIND_BEARING: ATTR_FORECAST_WIND_BEARING,
-    ATTR_API_FORECAST_WIND_SPEED: ATTR_FORECAST_NATIVE_WIND_SPEED,
-    ATTR_API_FORECAST_CLOUDS: ATTR_FORECAST_CLOUD_COVERAGE,
-    ATTR_API_FORECAST_HUMIDITY: ATTR_FORECAST_HUMIDITY,
-    ATTR_API_FORECAST_FEELS_LIKE_TEMPERATURE: ATTR_FORECAST_NATIVE_APPARENT_TEMP,
-}
-
 
 async def async_setup_entry(
     hass: HomeAssistant,
@@ -126,84 +85,66 @@ def __init__(
             manufacturer=MANUFACTURER,
             name=DEFAULT_NAME,
         )
-        if weather_coordinator.forecast_mode in (
-            FORECAST_MODE_DAILY,
-            FORECAST_MODE_ONECALL_DAILY,
-        ):
-            self._attr_supported_features = WeatherEntityFeature.FORECAST_DAILY
-        else:  # FORECAST_MODE_DAILY or FORECAST_MODE_ONECALL_HOURLY
-            self._attr_supported_features = WeatherEntityFeature.FORECAST_HOURLY
+        self._attr_supported_features = (
+            WeatherEntityFeature.FORECAST_DAILY | WeatherEntityFeature.FORECAST_HOURLY
+        )
 
     @property
     def condition(self) -> str | None:
         """Return the current condition."""
-        return self.coordinator.data[ATTR_API_CONDITION]
+        return self.coordinator.data[ATTR_API_CURRENT][ATTR_API_CONDITION]
 
     @property
     def cloud_coverage(self) -> float | None:
         """Return the Cloud coverage in %."""
-        return self.coordinator.data[ATTR_API_CLOUDS]
+        return self.coordinator.data[ATTR_API_CURRENT][ATTR_API_CLOUDS]
 
     @property
     def native_apparent_temperature(self) -> float | None:
         """Return the apparent temperature."""
-        return self.coordinator.data[ATTR_API_FEELS_LIKE_TEMPERATURE]
+        return self.coordinator.data[ATTR_API_CURRENT][ATTR_API_FEELS_LIKE_TEMPERATURE]
 
     @property
     def native_temperature(self) -> float | None:
         """Return the temperature."""
-        return self.coordinator.data[ATTR_API_TEMPERATURE]
+        return self.coordinator.data[ATTR_API_CURRENT][ATTR_API_TEMPERATURE]
 
     @property
     def native_pressure(self) -> float | None:
         """Return the pressure."""
-        return self.coordinator.data[ATTR_API_PRESSURE]
+        return self.coordinator.data[ATTR_API_CURRENT][ATTR_API_PRESSURE]
 
     @property
     def humidity(self) -> float | None:
         """Return the humidity."""
-        return self.coordinator.data[ATTR_API_HUMIDITY]
+        return self.coordinator.data[ATTR_API_CURRENT][ATTR_API_HUMIDITY]
 
     @property
     def native_dew_point(self) -> float | None:
         """Return the dew point."""
-        return self.coordinator.data[ATTR_API_DEW_POINT]
+        return self.coordinator.data[ATTR_API_CURRENT][ATTR_API_DEW_POINT]
 
     @property
     def native_wind_gust_speed(self) -> float | None:
         """Return the wind gust speed."""
-        return self.coordinator.data[ATTR_API_WIND_GUST]
+        return self.coordinator.data[ATTR_API_CURRENT][ATTR_API_WIND_GUST]
 
     @property
     def native_wind_speed(self) -> float | None:
         """Return the wind speed."""
-        return self.coordinator.data[ATTR_API_WIND_SPEED]
+        return self.coordinator.data[ATTR_API_CURRENT][ATTR_API_WIND_SPEED]
 
     @property
     def wind_bearing(self) -> float | str | None:
         """Return the wind bearing."""
-        return self.coordinator.data[ATTR_API_WIND_BEARING]
-
-    @property
-    def _forecast(self) -> list[Forecast] | None:
-        """Return the forecast array."""
-        api_forecasts = self.coordinator.data[ATTR_API_FORECAST]
-        forecasts = [
-            {
-                ha_key: forecast[api_key]
-                for api_key, ha_key in FORECAST_MAP.items()
-                if api_key in forecast
-            }
-            for forecast in api_forecasts
-        ]
-        return cast(list[Forecast], forecasts)
+        return self.coordinator.data[ATTR_API_CURRENT][ATTR_API_WIND_BEARING]
 
     @callback
     def _async_forecast_daily(self) -> list[Forecast] | None:
         """Return the daily forecast in native units."""
-        return self._forecast
+        return self.coordinator.data[ATTR_API_DAILY_FORECAST]
 
     @callback
     def _async_forecast_hourly(self) -> list[Forecast] | None:
         """Return the hourly forecast in native units."""
-        return self._forecast
+        return self.coordinator.data[ATTR_API_HOURLY_FORECAST]