[pull] dev from home-assistant:dev

homeassistant/components/airgradient/update.py

@@ -1,7 +1,9 @@
 """Airgradient Update platform."""
 
 from datetime import timedelta
+import logging
 
+from airgradient import AirGradientConnectionError
 from propcache.api import cached_property
 
 from homeassistant.components.update import UpdateDeviceClass, UpdateEntity
@@ -13,6 +15,7 @@
 
 PARALLEL_UPDATES = 1
 SCAN_INTERVAL = timedelta(hours=1)
+_LOGGER = logging.getLogger(__name__)
 
 
 async def async_setup_entry(
@@ -31,6 +34,7 @@ class AirGradientUpdate(AirGradientEntity, UpdateEntity):
     """Representation of Airgradient Update."""
 
     _attr_device_class = UpdateDeviceClass.FIRMWARE
+    _server_unreachable_logged = False
 
     def __init__(self, coordinator: AirGradientCoordinator) -> None:
         """Initialize the entity."""
@@ -47,10 +51,27 @@ def installed_version(self) -> str:
         """Return the installed version of the entity."""
         return self.coordinator.data.measures.firmware_version
 
+    @property
+    def available(self) -> bool:
+        """Return if entity is available."""
+        return super().available and self._attr_available
+
     async def async_update(self) -> None:
         """Update the entity."""
-        self._attr_latest_version = (
-            await self.coordinator.client.get_latest_firmware_version(
-                self.coordinator.serial_number
+        try:
+            self._attr_latest_version = (
+                await self.coordinator.client.get_latest_firmware_version(
+                    self.coordinator.serial_number
+                )
             )
-        )
+        except AirGradientConnectionError:
+            self._attr_latest_version = None
+            self._attr_available = False
+            if not self._server_unreachable_logged:
+                _LOGGER.error(
+                    "Unable to connect to AirGradient server to check for updates"
+                )
+                self._server_unreachable_logged = True
+        else:
+            self._server_unreachable_logged = False
+            self._attr_available = True

homeassistant/components/idasen_desk/coordinator.py

@@ -41,16 +41,12 @@ def __init__(
         self._expected_connected = False
         self._height: int | None = None
 
-        @callback
-        def async_update_data() -> None:
-            self.async_set_updated_data(self._height)
-
         self._debouncer = Debouncer(
             hass=self.hass,
             logger=_LOGGER,
             cooldown=UPDATE_DEBOUNCE_TIME,
             immediate=True,
-            function=async_update_data,
+            function=callback(lambda: self.async_set_updated_data(self._height)),
         )
 
     async def async_connect(self) -> bool:

homeassistant/components/mcp/config_flow.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 from collections.abc import Mapping
+from dataclasses import dataclass
 import logging
 from typing import Any, cast
 
@@ -23,7 +24,13 @@
 
 from . import async_get_config_entry_implementation
 from .application_credentials import authorization_server_context
-from .const import CONF_ACCESS_TOKEN, CONF_AUTHORIZATION_URL, CONF_TOKEN_URL, DOMAIN
+from .const import (
+    CONF_ACCESS_TOKEN,
+    CONF_AUTHORIZATION_URL,
+    CONF_SCOPE,
+    CONF_TOKEN_URL,
+    DOMAIN,
+)
 from .coordinator import TokenManager, mcp_client
 
 _LOGGER = logging.getLogger(__name__)
@@ -41,9 +48,17 @@
 }
 
 
+@dataclass
+class OAuthConfig:
+    """Class to hold OAuth configuration."""
+
+    authorization_server: AuthorizationServer
+    scopes: list[str] | None = None
+
+
 async def async_discover_oauth_config(
     hass: HomeAssistant, mcp_server_url: str
-) -> AuthorizationServer:
+) -> OAuthConfig:
     """Discover the OAuth configuration for the MCP server.
 
     This implements the functionality in the MCP spec for discovery. If the MCP server URL
@@ -65,9 +80,11 @@ async def async_discover_oauth_config(
     except httpx.HTTPStatusError as error:
         if error.response.status_code == 404:
             _LOGGER.info("Authorization Server Metadata not found, using default paths")
-            return AuthorizationServer(
-                authorize_url=str(parsed_url.with_path("/authorize")),
-                token_url=str(parsed_url.with_path("/token")),
+            return OAuthConfig(
+                authorization_server=AuthorizationServer(
+                    authorize_url=str(parsed_url.with_path("/authorize")),
+                    token_url=str(parsed_url.with_path("/token")),
+                )
             )
         raise CannotConnect from error
     except httpx.HTTPError as error:
@@ -81,9 +98,15 @@ async def async_discover_oauth_config(
         authorize_url = str(parsed_url.with_path(authorize_url))
     if token_url.startswith("/"):
         token_url = str(parsed_url.with_path(token_url))
-    return AuthorizationServer(
-        authorize_url=authorize_url,
-        token_url=token_url,
+    # We have no way to know the minimum set of scopes needed, so request
+    # all of them and let the user limit during the authorization step.
+    scopes = data.get("scopes_supported")
+    return OAuthConfig(
+        authorization_server=AuthorizationServer(
+            authorize_url=authorize_url,
+            token_url=token_url,
+        ),
+        scopes=scopes,
     )
 
 
@@ -130,6 +153,7 @@ def __init__(self) -> None:
         """Initialize the config flow."""
         super().__init__()
         self.data: dict[str, Any] = {}
+        self.oauth_config: OAuthConfig | None = None
 
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
@@ -170,7 +194,7 @@ async def async_step_auth_discovery(
         to find the OAuth medata then run the OAuth authentication flow.
         """
         try:
-            authorization_server = await async_discover_oauth_config(
+            oauth_config = await async_discover_oauth_config(
                 self.hass, self.data[CONF_URL]
             )
         except TimeoutConnectError:
@@ -181,11 +205,13 @@ async def async_step_auth_discovery(
             _LOGGER.exception("Unexpected exception")
             return self.async_abort(reason="unknown")
         else:
-            _LOGGER.info("OAuth configuration: %s", authorization_server)
+            _LOGGER.info("OAuth configuration: %s", oauth_config)
+            self.oauth_config = oauth_config
             self.data.update(
                 {
-                    CONF_AUTHORIZATION_URL: authorization_server.authorize_url,
-                    CONF_TOKEN_URL: authorization_server.token_url,
+                    CONF_AUTHORIZATION_URL: oauth_config.authorization_server.authorize_url,
+                    CONF_TOKEN_URL: oauth_config.authorization_server.token_url,
+                    CONF_SCOPE: oauth_config.scopes,
                 }
             )
             return await self.async_step_credentials_choice()
@@ -197,6 +223,15 @@ def authorization_server(self) -> AuthorizationServer:
             self.data[CONF_TOKEN_URL],
         )
 
+    @property
+    def extra_authorize_data(self) -> dict:
+        """Extra data that needs to be appended to the authorize url."""
+        data = {}
+        if self.data and (scopes := self.data[CONF_SCOPE]) is not None:
+            data[CONF_SCOPE] = " ".join(scopes)
+        data.update(super().extra_authorize_data)
+        return data
+
     async def async_step_credentials_choice(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:

homeassistant/components/mcp/const.py

@@ -5,3 +5,4 @@
 CONF_ACCESS_TOKEN = "access_token"
 CONF_AUTHORIZATION_URL = "authorization_url"
 CONF_TOKEN_URL = "token_url"
+CONF_SCOPE = "scope"

homeassistant/components/miele/sensor.py

@@ -54,6 +54,7 @@
 DEFAULT_PLATE_COUNT = 4
 
 PLATE_COUNT = {
+    "KM7575": 6,
     "KM7678": 6,
     "KM7697": 6,
     "KM7878": 6,

homeassistant/components/nintendo_parental/__init__.py

@@ -0,0 +1,51 @@
+"""The Nintendo Switch Parental Controls integration."""
+
+from __future__ import annotations
+
+from pynintendoparental import Authenticator
+from pynintendoparental.exceptions import (
+    InvalidOAuthConfigurationException,
+    InvalidSessionTokenException,
+)
+
+from homeassistant.const import Platform
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryError
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+
+from .const import CONF_SESSION_TOKEN, DOMAIN
+from .coordinator import NintendoParentalConfigEntry, NintendoUpdateCoordinator
+
+_PLATFORMS: list[Platform] = [Platform.SENSOR]
+
+
+async def async_setup_entry(
+    hass: HomeAssistant, entry: NintendoParentalConfigEntry
+) -> bool:
+    """Set up Nintendo Switch Parental Controls from a config entry."""
+    try:
+        nintendo_auth = await Authenticator.complete_login(
+            auth=None,
+            response_token=entry.data[CONF_SESSION_TOKEN],
+            is_session_token=True,
+            client_session=async_get_clientsession(hass),
+        )
+    except (InvalidSessionTokenException, InvalidOAuthConfigurationException) as err:
+        raise ConfigEntryError(
+            translation_domain=DOMAIN,
+            translation_key="auth_expired",
+        ) from err
+    entry.runtime_data = coordinator = NintendoUpdateCoordinator(
+        hass, nintendo_auth, entry
+    )
+    await coordinator.async_config_entry_first_refresh()
+    await hass.config_entries.async_forward_entry_setups(entry, _PLATFORMS)
+
+    return True
+
+
+async def async_unload_entry(
+    hass: HomeAssistant, entry: NintendoParentalConfigEntry
+) -> bool:
+    """Unload a config entry."""
+    return await hass.config_entries.async_unload_platforms(entry, _PLATFORMS)

homeassistant/components/nintendo_parental/config_flow.py

@@ -0,0 +1,61 @@
+"""Config flow for the Nintendo Switch Parental Controls integration."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+from pynintendoparental import Authenticator
+from pynintendoparental.exceptions import HttpException, InvalidSessionTokenException
+import voluptuous as vol
+
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_API_TOKEN
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+
+from .const import CONF_SESSION_TOKEN, DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class NintendoConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for Nintendo Switch Parental Controls."""
+
+    def __init__(self) -> None:
+        """Initialize a new config flow instance."""
+        self.auth: Authenticator | None = None
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the initial step."""
+        errors = {}
+        if self.auth is None:
+            self.auth = Authenticator.generate_login(
+                client_session=async_get_clientsession(self.hass)
+            )
+
+        if user_input is not None:
+            try:
+                await self.auth.complete_login(
+                    self.auth, user_input[CONF_API_TOKEN], False
+                )
+            except (ValueError, InvalidSessionTokenException, HttpException):
+                errors["base"] = "invalid_auth"
+            else:
+                if TYPE_CHECKING:
+                    assert self.auth.account_id
+                await self.async_set_unique_id(self.auth.account_id)
+                self._abort_if_unique_id_configured()
+                return self.async_create_entry(
+                    title=self.auth.account_id,
+                    data={
+                        CONF_SESSION_TOKEN: self.auth.get_session_token,
+                    },
+                )
+        return self.async_show_form(
+            step_id="user",
+            description_placeholders={"link": self.auth.login_url},
+            data_schema=vol.Schema({vol.Required(CONF_API_TOKEN): str}),
+            errors=errors,
+        )

homeassistant/components/nintendo_parental/const.py

@@ -0,0 +1,5 @@
+"""Constants for the Nintendo Switch Parental Controls integration."""
+
+DOMAIN = "nintendo_parental"
+CONF_UPDATE_INTERVAL = "update_interval"
+CONF_SESSION_TOKEN = "session_token"

homeassistant/components/nintendo_parental/coordinator.py

@@ -0,0 +1,52 @@
+"""Nintendo Parental Controls data coordinator."""
+
+from __future__ import annotations
+
+from datetime import timedelta
+import logging
+
+from pynintendoparental import Authenticator, NintendoParental
+from pynintendoparental.exceptions import InvalidOAuthConfigurationException
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryError
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
+
+from .const import DOMAIN
+
+type NintendoParentalConfigEntry = ConfigEntry[NintendoUpdateCoordinator]
+
+_LOGGER = logging.getLogger(__name__)
+UPDATE_INTERVAL = timedelta(seconds=60)
+
+
+class NintendoUpdateCoordinator(DataUpdateCoordinator[None]):
+    """Nintendo data update coordinator."""
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        authenticator: Authenticator,
+        config_entry: NintendoParentalConfigEntry,
+    ) -> None:
+        """Initialize update coordinator."""
+        super().__init__(
+            hass=hass,
+            logger=_LOGGER,
+            name=DOMAIN,
+            update_interval=UPDATE_INTERVAL,
+            config_entry=config_entry,
+        )
+        self.api = NintendoParental(
+            authenticator, hass.config.time_zone, hass.config.language
+        )
+
+    async def _async_update_data(self) -> None:
+        """Update data from Nintendo's API."""
+        try:
+            return await self.api.update()
+        except InvalidOAuthConfigurationException as err:
+            raise ConfigEntryError(
+                err, translation_domain=DOMAIN, translation_key="invalid_auth"
+            ) from err