[pull] dev from home-assistant:dev

homeassistant/components/senz/__init__.py

@@ -12,10 +12,11 @@
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
-from homeassistant.helpers import (
-    config_entry_oauth2_flow,
-    config_validation as cv,
-    httpx_client,
+from homeassistant.helpers import config_validation as cv, httpx_client
+from homeassistant.helpers.config_entry_oauth2_flow import (
+    ImplementationUnavailableError,
+    OAuth2Session,
+    async_get_config_entry_implementation,
 )
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
@@ -28,19 +29,21 @@
 
 CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 
-PLATFORMS = [Platform.CLIMATE]
+PLATFORMS = [Platform.CLIMATE, Platform.SENSOR]
 
 type SENZDataUpdateCoordinator = DataUpdateCoordinator[dict[str, Thermostat]]
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up SENZ from a config entry."""
-    implementation = (
-        await config_entry_oauth2_flow.async_get_config_entry_implementation(
-            hass, entry
-        )
-    )
-    session = config_entry_oauth2_flow.OAuth2Session(hass, entry, implementation)
+    try:
+        implementation = await async_get_config_entry_implementation(hass, entry)
+    except ImplementationUnavailableError as err:
+        raise ConfigEntryNotReady(
+            translation_domain=DOMAIN,
+            translation_key="oauth2_implementation_unavailable",
+        ) from err
+    session = OAuth2Session(hass, entry, implementation)
     auth = SENZConfigEntryAuth(httpx_client.get_async_client(hass), session)
     senz_api = SENZAPI(auth)
 

homeassistant/components/senz/climate.py

@@ -35,7 +35,7 @@ async def async_setup_entry(
     )
 
 
-class SENZClimate(CoordinatorEntity, ClimateEntity):
+class SENZClimate(CoordinatorEntity[SENZDataUpdateCoordinator], ClimateEntity):
     """Representation of a SENZ climate entity."""
 
     _attr_temperature_unit = UnitOfTemperature.CELSIUS

homeassistant/components/senz/diagnostics.py

@@ -0,0 +1,29 @@
+"""Diagnostics platform for Senz integration."""
+
+from typing import Any
+
+from homeassistant.components.diagnostics import async_redact_data
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+
+from .const import DOMAIN
+
+TO_REDACT = [
+    "access_token",
+    "refresh_token",
+]
+
+
+async def async_get_config_entry_diagnostics(
+    hass: HomeAssistant, entry: ConfigEntry
+) -> dict[str, Any]:
+    """Return diagnostics for a config entry."""
+
+    raw_data = (
+        [device.raw_data for device in hass.data[DOMAIN][entry.entry_id].data.values()],
+    )
+
+    return {
+        "entry_data": async_redact_data(entry.data, TO_REDACT),
+        "thermostats": raw_data,
+    }

homeassistant/components/senz/sensor.py

@@ -0,0 +1,93 @@
+"""nVent RAYCHEM SENZ sensor platform."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+
+from aiosenz import Thermostat
+
+from homeassistant.components.sensor import (
+    SensorDeviceClass,
+    SensorEntity,
+    SensorEntityDescription,
+    SensorStateClass,
+)
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import UnitOfTemperature
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from . import SENZDataUpdateCoordinator
+from .const import DOMAIN
+
+
+@dataclass(kw_only=True, frozen=True)
+class SenzSensorDescription(SensorEntityDescription):
+    """Describes SENZ sensor entity."""
+
+    value_fn: Callable[[Thermostat], str | int | float | None]
+
+
+SENSORS: tuple[SenzSensorDescription, ...] = (
+    SenzSensorDescription(
+        key="temperature",
+        device_class=SensorDeviceClass.TEMPERATURE,
+        value_fn=lambda data: data.current_temperatue,
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        state_class=SensorStateClass.MEASUREMENT,
+        suggested_display_precision=1,
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: ConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up the SENZ sensor entities from a config entry."""
+    coordinator: SENZDataUpdateCoordinator = hass.data[DOMAIN][entry.entry_id]
+    async_add_entities(
+        SENZSensor(thermostat, coordinator, description)
+        for description in SENSORS
+        for thermostat in coordinator.data.values()
+    )
+
+
+class SENZSensor(CoordinatorEntity[SENZDataUpdateCoordinator], SensorEntity):
+    """Representation of a SENZ sensor entity."""
+
+    entity_description: SenzSensorDescription
+    _attr_has_entity_name = True
+
+    def __init__(
+        self,
+        thermostat: Thermostat,
+        coordinator: SENZDataUpdateCoordinator,
+        description: SenzSensorDescription,
+    ) -> None:
+        """Init SENZ sensor."""
+        super().__init__(coordinator)
+        self.entity_description = description
+        self._thermostat = thermostat
+        self._attr_unique_id = f"{thermostat.serial_number}_{description.key}"
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, thermostat.serial_number)},
+            manufacturer="nVent Raychem",
+            model="SENZ WIFI",
+            name=thermostat.name,
+            serial_number=thermostat.serial_number,
+        )
+
+    @property
+    def available(self) -> bool:
+        """Return True if the thermostat is available."""
+        return super().available and self._thermostat.online
+
+    @property
+    def native_value(self) -> str | float | int | None:
+        """Return the state of the sensor."""
+        return self.entity_description.value_fn(self._thermostat)

homeassistant/components/senz/strings.json

@@ -25,5 +25,10 @@
         "title": "[%key:common::config_flow::title::oauth2_pick_implementation%]"
       }
     }
+  },
+  "exceptions": {
+    "oauth2_implementation_unavailable": {
+      "message": "[%key:common::exceptions::oauth2_implementation_unavailable::message%]"
+    }
   }
 }

homeassistant/components/transmission/services.py

@@ -2,13 +2,14 @@
 
 from functools import partial
 import logging
+from typing import cast
 
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigEntryState
 from homeassistant.const import CONF_ID
 from homeassistant.core import HomeAssistant, ServiceCall, callback
-from homeassistant.exceptions import HomeAssistantError
+from homeassistant.exceptions import ServiceValidationError
 from homeassistant.helpers import config_validation as cv, selector
 
 from .const import (
@@ -23,7 +24,7 @@
     SERVICE_START_TORRENT,
     SERVICE_STOP_TORRENT,
 )
-from .coordinator import TransmissionConfigEntry, TransmissionDataUpdateCoordinator
+from .coordinator import TransmissionDataUpdateCoordinator
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -67,63 +68,68 @@
 
 
 def _get_coordinator_from_service_data(
-    hass: HomeAssistant, entry_id: str
+    call: ServiceCall,
 ) -> TransmissionDataUpdateCoordinator:
     """Return coordinator for entry id."""
-    entry: TransmissionConfigEntry | None = hass.config_entries.async_get_entry(
-        entry_id
-    )
-    if entry is None or entry.state is not ConfigEntryState.LOADED:
-        raise HomeAssistantError(f"Config entry {entry_id} is not found or not loaded")
-    return entry.runtime_data
+    config_entry_id: str = call.data[CONF_ENTRY_ID]
+    if not (entry := call.hass.config_entries.async_get_entry(config_entry_id)):
+        raise ServiceValidationError(
+            translation_domain=DOMAIN,
+            translation_key="integration_not_found",
+            translation_placeholders={"target": DOMAIN},
+        )
+    if entry.state is not ConfigEntryState.LOADED:
+        raise ServiceValidationError(
+            translation_domain=DOMAIN,
+            translation_key="not_loaded",
+            translation_placeholders={"target": entry.title},
+        )
+    return cast(TransmissionDataUpdateCoordinator, entry.runtime_data)
 
 
 async def _async_add_torrent(service: ServiceCall) -> None:
     """Add new torrent to download."""
-    entry_id: str = service.data[CONF_ENTRY_ID]
-    coordinator = _get_coordinator_from_service_data(service.hass, entry_id)
+    coordinator = _get_coordinator_from_service_data(service)
     torrent: str = service.data[ATTR_TORRENT]
     download_path: str | None = service.data.get(ATTR_DOWNLOAD_PATH)
-    if torrent.startswith(
-        ("http", "ftp:", "magnet:")
-    ) or service.hass.config.is_allowed_path(torrent):
-        if download_path:
-            await service.hass.async_add_executor_job(
-                partial(
-                    coordinator.api.add_torrent, torrent, download_dir=download_path
-                )
-            )
-        else:
-            await service.hass.async_add_executor_job(
-                coordinator.api.add_torrent, torrent
-            )
-        await coordinator.async_request_refresh()
+
+    if not (
+        torrent.startswith(("http", "ftp:", "magnet:"))
+        or service.hass.config.is_allowed_path(torrent)
+    ):
+        raise ServiceValidationError(
+            translation_domain=DOMAIN,
+            translation_key="could_not_add_torrent",
+        )
+
+    if download_path:
+        await service.hass.async_add_executor_job(
+            partial(coordinator.api.add_torrent, torrent, download_dir=download_path)
+        )
     else:
-        _LOGGER.warning("Could not add torrent: unsupported type or no permission")
+        await service.hass.async_add_executor_job(coordinator.api.add_torrent, torrent)
+    await coordinator.async_request_refresh()
 
 
 async def _async_start_torrent(service: ServiceCall) -> None:
     """Start torrent."""
-    entry_id: str = service.data[CONF_ENTRY_ID]
-    coordinator = _get_coordinator_from_service_data(service.hass, entry_id)
+    coordinator = _get_coordinator_from_service_data(service)
     torrent_id = service.data[CONF_ID]
     await service.hass.async_add_executor_job(coordinator.api.start_torrent, torrent_id)
     await coordinator.async_request_refresh()
 
 
 async def _async_stop_torrent(service: ServiceCall) -> None:
     """Stop torrent."""
-    entry_id: str = service.data[CONF_ENTRY_ID]
-    coordinator = _get_coordinator_from_service_data(service.hass, entry_id)
+    coordinator = _get_coordinator_from_service_data(service)
     torrent_id = service.data[CONF_ID]
     await service.hass.async_add_executor_job(coordinator.api.stop_torrent, torrent_id)
     await coordinator.async_request_refresh()
 
 
 async def _async_remove_torrent(service: ServiceCall) -> None:
     """Remove torrent."""
-    entry_id: str = service.data[CONF_ENTRY_ID]
-    coordinator = _get_coordinator_from_service_data(service.hass, entry_id)
+    coordinator = _get_coordinator_from_service_data(service)
     torrent_id = service.data[CONF_ID]
     delete_data = service.data[ATTR_DELETE_DATA]
     await service.hass.async_add_executor_job(

homeassistant/components/transmission/services.yaml

@@ -1,6 +1,7 @@
 add_torrent:
   fields:
     entry_id:
+      required: true
       selector:
         config_entry:
           integration: transmission
@@ -18,6 +19,7 @@ add_torrent:
 remove_torrent:
   fields:
     entry_id:
+      required: true
       selector:
         config_entry:
           integration: transmission
@@ -27,24 +29,28 @@ remove_torrent:
       selector:
         text:
     delete_data:
+      required: true
       default: false
       selector:
         boolean:
 
 start_torrent:
   fields:
     entry_id:
+      required: true
       selector:
         config_entry:
           integration: transmission
     id:
+      required: true
       example: 123
       selector:
         text:
 
 stop_torrent:
   fields:
     entry_id:
+      required: true
       selector:
         config_entry:
           integration: transmission

homeassistant/components/transmission/strings.json

@@ -87,6 +87,17 @@
       }
     }
   },
+  "exceptions": {
+    "could_not_add_torrent": {
+      "message": "Could not add torrent: unsupported type or no permission."
+    },
+    "integration_not_found": {
+      "message": "Integration \"{target}\" not found in registry."
+    },
+    "not_loaded": {
+      "message": "{target} is not loaded."
+    }
+  },
   "options": {
     "step": {
       "init": {