[pull] dev from home-assistant:dev

.strict-typing

@@ -118,6 +118,7 @@ homeassistant.components.bayesian.*
 homeassistant.components.besen.*
 homeassistant.components.binary_sensor.*
 homeassistant.components.bitcoin.*
+homeassistant.components.bitvis.*
 homeassistant.components.blockchain.*
 homeassistant.components.blue_current.*
 homeassistant.components.blueprint.*

homeassistant/components/airly/config_flow.py

@@ -2,9 +2,10 @@
 
 from asyncio import timeout
 from http import HTTPStatus
+import logging
 from typing import Any, override
 
-from aiohttp import ClientSession
+from aiohttp import ClientConnectorError, ClientSession
 from airly import Airly
 from airly.exceptions import AirlyError
 import voluptuous as vol
@@ -14,11 +15,18 @@
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 
-from .const import CONF_USE_NEAREST, DEFAULT_NAME, DOMAIN, NO_AIRLY_SENSORS
+from .const import (
+    CONF_USE_NEAREST,
+    DEFAULT_NAME,
+    DEFAULT_TIMEOUT,
+    DOMAIN,
+    NO_AIRLY_SENSORS,
+)
 
 DESCRIPTION_PLACEHOLDERS = {
     "developer_registration_url": "https://developer.airly.eu/register",
 }
+_LOGGER = logging.getLogger(__name__)
 
 
 class AirlyFlowHandler(ConfigFlow, domain=DOMAIN):
@@ -59,8 +67,15 @@ async def async_step_user(
             except AirlyError as err:
                 if err.status_code == HTTPStatus.UNAUTHORIZED:
                     errors["base"] = "invalid_api_key"
-                if err.status_code == HTTPStatus.NOT_FOUND:
+                elif err.status_code == HTTPStatus.NOT_FOUND:
                     errors["base"] = "wrong_location"
+                else:
+                    errors["base"] = "unknown"
+            except ClientConnectorError, TimeoutError:
+                errors["base"] = "cannot_connect"
+            except Exception:
+                _LOGGER.exception("Unexpected exception")
+                errors["base"] = "unknown"
             else:
                 if not location_point_valid:
                     if not location_nearest_valid:
@@ -106,7 +121,7 @@ async def check_location(
         measurements = airly.create_measurements_session_point(
             latitude=latitude, longitude=longitude
         )
-    async with timeout(10):
+    async with timeout(DEFAULT_TIMEOUT):
         await measurements.update()
 
     current = measurements.current

homeassistant/components/airly/const.py

@@ -37,3 +37,4 @@
 URL = "https://airly.org/map/#{latitude},{longitude}"
 
 DEFAULT_NAME: Final = "Airly"
+DEFAULT_TIMEOUT = 10

homeassistant/components/airly/coordinator.py

@@ -21,6 +21,7 @@
     ATTR_API_CAQI,
     ATTR_API_CAQI_DESCRIPTION,
     ATTR_API_CAQI_LEVEL,
+    DEFAULT_TIMEOUT,
     DOMAIN,
     MAX_UPDATE_INTERVAL,
     MIN_UPDATE_INTERVAL,
@@ -103,18 +104,18 @@ async def _async_update_data(self) -> dict[str, str | float | int]:
             measurements = self.airly.create_measurements_session_point(
                 self.latitude, self.longitude
             )
-        async with timeout(20):
-            try:
+        try:
+            async with timeout(DEFAULT_TIMEOUT):
                 await measurements.update()
-            except (AirlyError, ClientConnectorError) as error:
-                raise UpdateFailed(
-                    translation_domain=DOMAIN,
-                    translation_key="update_error",
-                    translation_placeholders={
-                        "entry": self.config_entry.title,
-                        "error": repr(error),
-                    },
-                ) from error
+        except (AirlyError, ClientConnectorError, TimeoutError) as error:
+            raise UpdateFailed(
+                translation_domain=DOMAIN,
+                translation_key="update_error",
+                translation_placeholders={
+                    "entry": self.config_entry.title,
+                    "error": repr(error),
+                },
+            ) from error
 
         _LOGGER.debug(
             "Requests remaining: %s/%s",

homeassistant/components/airly/strings.json

@@ -5,7 +5,9 @@
       "wrong_location": "[%key:component::airly::config::error::wrong_location%]"
     },
     "error": {
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
       "invalid_api_key": "[%key:common::config_flow::error::invalid_api_key%]",
+      "unknown": "[%key:common::config_flow::error::unknown%]",
       "wrong_location": "No Airly measuring stations in this area."
     },
     "step": {

homeassistant/components/bitvis/__init__.py

@@ -0,0 +1,56 @@
+"""The Bitvis Power Hub integration."""
+
+from typing import TYPE_CHECKING
+
+from homeassistant.const import CONF_PORT, Platform
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.typing import ConfigType
+
+from .const import DATA_LISTENER_REGISTRY, DOMAIN
+from .coordinator import (
+    BitvisConfigEntry,
+    BitvisDataUpdateCoordinator,
+    async_get_listener_registry,
+)
+
+_PLATFORMS: list[Platform] = [Platform.SENSOR]
+
+CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
+
+
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up the Bitvis Power Hub integration."""
+    async_get_listener_registry(hass)
+    return True
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: BitvisConfigEntry) -> bool:
+    """Set up Bitvis Power Hub from a config entry."""
+    async_get_listener_registry(hass)
+    if TYPE_CHECKING:
+        assert entry.unique_id is not None
+    coordinator = BitvisDataUpdateCoordinator(
+        hass,
+        entry,
+        entry.data[CONF_PORT],
+        entry.unique_id,
+    )
+
+    await coordinator.async_config_entry_first_refresh()
+
+    entry.runtime_data = coordinator
+
+    await hass.config_entries.async_forward_entry_setups(entry, _PLATFORMS)
+
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: BitvisConfigEntry) -> bool:
+    """Unload a config entry."""
+    unload_ok = await hass.config_entries.async_unload_platforms(entry, _PLATFORMS)
+    if unload_ok:
+        await entry.runtime_data.async_stop()
+        if not hass.config_entries.async_loaded_entries(DOMAIN):
+            hass.data.pop(DATA_LISTENER_REGISTRY, None)
+    return unload_ok