[pull] dev from home-assistant:dev

homeassistant/components/august/util.py

@@ -1,6 +1,6 @@
 """August util functions."""
 
-from datetime import datetime, timedelta
+from datetime import timedelta
 from functools import partial
 
 import aiohttp
@@ -11,6 +11,7 @@
 
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers import aiohttp_client
+from homeassistant.util import dt as dt_util
 
 from . import AugustData
 
@@ -61,7 +62,7 @@ def _activity_time_based(latest: Activity) -> Activity | None:
     """Get the latest state of the sensor."""
     start = latest.activity_start_time
     end = latest.activity_end_time + TIME_TO_DECLARE_DETECTION
-    if start <= datetime.now() <= end:  # pylint: disable=home-assistant-enforce-naive-now
+    if start <= dt_util.naive_now() <= end:
         return latest
     return None
 

homeassistant/components/broadlink/heartbeat.py

@@ -8,6 +8,7 @@
 from homeassistant.const import CONF_HOST
 from homeassistant.core import CALLBACK_TYPE, HomeAssistant
 from homeassistant.helpers import event
+from homeassistant.util import dt as dt_util
 
 from .const import DOMAIN
 
@@ -31,7 +32,7 @@ def __init__(self, hass: HomeAssistant) -> None:
     async def async_setup(self) -> None:
         """Set up the heartbeat."""
         if self._unsubscribe is None:
-            await self.async_heartbeat(dt.datetime.now())  # pylint: disable=home-assistant-enforce-naive-now
+            await self.async_heartbeat(dt_util.utcnow())
             self._unsubscribe = event.async_track_time_interval(
                 self._hass, self.async_heartbeat, self.HEARTBEAT_INTERVAL
             )

homeassistant/components/caldav/api.py

@@ -1,5 +1,4 @@
 """Library for working with CalDAV api."""
-# pylint: disable=home-assistant-use-runtime-data  # Uses legacy hass.data[DOMAIN] pattern
 
 import logging
 
@@ -8,7 +7,7 @@
 
 from homeassistant.core import HomeAssistant
 
-from .const import DOMAIN
+from .const import WARNED_CALENDARS
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -45,9 +44,7 @@ def _get_calendars() -> tuple[
     calendars, needs_warning = await hass.async_add_executor_job(_get_calendars)
 
     if needs_warning:
-        warned_calendars: set[tuple[str, str]] = hass.data.setdefault(
-            DOMAIN, {}
-        ).setdefault("warned_calendars", set())
+        warned_calendars = hass.data.setdefault(WARNED_CALENDARS, set())
         for url, name, comp in needs_warning:
             # This workaround and warning can be removed when we upgrade to caldav 3.0
             if (url, comp) not in warned_calendars:

homeassistant/components/caldav/const.py

@@ -2,5 +2,12 @@
 
 from typing import Final
 
+from homeassistant.util.hass_dict import HassKey
+
 DOMAIN: Final = "caldav"
 TIMEOUT: Final = 30
+
+# Calendars we have already warned about, keyed by (url, component). This is
+# deliberately not stored on a config entry: the warning is per CalDAV server
+# and must survive reloads, and the same server may back more than one entry.
+WARNED_CALENDARS: HassKey[set[tuple[str, str]]] = HassKey(f"{DOMAIN}_warned_calendars")

homeassistant/components/compensation/manifest.json

@@ -5,5 +5,5 @@
   "documentation": "https://www.home-assistant.io/integrations/compensation",
   "iot_class": "calculated",
   "quality_scale": "legacy",
-  "requirements": ["numpy==2.3.2"]
+  "requirements": ["numpy==2.5.2"]
 }

homeassistant/components/derivative/sensor.py

@@ -489,7 +489,8 @@ def calc_derivative(
             old_timestamp: datetime,
         ) -> None:
             """Handle the sensor state changes."""
-            if not _is_decimal_state(old_value):
+            recovered_from_invalid = not _is_decimal_state(old_value)
+            if recovered_from_invalid:
                 if self._last_valid_state_time:
                     old_value = self._last_valid_state_time[0]
                     old_timestamp = self._last_valid_state_time[1]
@@ -550,6 +551,12 @@ def calc_derivative(
                     "%s: Dropping sample as source total_increasing sensor decreased",
                     self.entity_id,
                 )
+                if recovered_from_invalid:
+                    # Reset while recovering from an invalid source: re-baseline
+                    # and report zero so the entity doesn't stay stuck unavailable.
+                    self._state_list = []
+                    self._last_valid_state_time = (new_state.state, new_timestamp)
+                    self._write_native_value(Decimal(0))
                 return
 
             # add latest derivative to the window list

homeassistant/components/devolo_home_network/device_tracker.py

@@ -75,6 +75,7 @@ def restore_entities() -> None:
         async_add_entities(missing)
 
     restore_entities()
+    new_device_callback()
     entry.async_on_unload(
         coordinators[CONNECTED_WIFI_CLIENTS].async_add_listener(new_device_callback)
     )

homeassistant/components/enphase_envoy/diagnostics.py

@@ -4,7 +4,7 @@
 from datetime import datetime
 from typing import TYPE_CHECKING, Any
 
-from aiohttp import ClientResponse
+from aiohttp import ClientError, ClientResponse
 from pyenphase.envoy import Envoy
 from pyenphase.exceptions import EnvoyError
 
@@ -92,6 +92,10 @@ async def _get_fixture_collection(envoy: Envoy, serial: str) -> dict[str, Any]:
                     "code": response.status,
                 }
             )
+        except ClientError as err:
+            fixture_data[f"{end_point}_log"] = {
+                "Error": f"Aiohttp Client error {type(err).__name__ if not hasattr(err, 'status') else err.status}"
+            }
         except EnvoyError as err:
             fixture_data[f"{end_point}_log"] = {"Error": repr(err)}
     return fixture_data

homeassistant/components/enphase_envoy/manifest.json

@@ -8,7 +8,7 @@
   "iot_class": "local_polling",
   "loggers": ["pyenphase"],
   "quality_scale": "platinum",
-  "requirements": ["pyenphase==3.2.1"],
+  "requirements": ["pyenphase==4.0.0"],
   "zeroconf": [
     {
       "type": "_enphase-envoy._tcp.local."

homeassistant/components/enphase_envoy/sensor.py

@@ -21,7 +21,7 @@
     EnvoySystemConsumption,
     EnvoySystemProduction,
 )
-from pyenphase.const import PHASENAMES
+from pyenphase.const import PHASENAMES, SupportedFeatures
 from pyenphase.models.acb import ACBChargeStatus, ACBSleepState
 from pyenphase.models.meters import (
     CtMeterStatus,
@@ -383,7 +383,7 @@ class EnvoyCTSensorEntityDescription(SensorEntityDescription):
     """Describes an Envoy CT sensor entity."""
 
     value_fn: Callable[
-        [EnvoyMeterData],
+        [EnvoyMeterData | None],
         int | float | str | CtType | CtMeterStatus | CtStatusFlags | CtState | None,
     ]
     on_phase: str | None = None
@@ -586,7 +586,9 @@ class EnvoyCTSensorEntityDescription(SensorEntityDescription):
             translation_key=(translation_key if translation_key != "" else key),
             entity_category=EntityCategory.DIAGNOSTIC,
             entity_registry_enabled_default=False,
-            value_fn=lambda ct: 0 if ct.status_flags is None else len(ct.status_flags),
+            value_fn=lambda ct: (
+                0 if ct is None or ct.status_flags is None else len(ct.status_flags)
+            ),
             cttype=cttype,
         )
         for cttype, key, translation_key in (
@@ -1020,47 +1022,67 @@ async def async_setup_entry(
 ) -> None:
     """Set up envoy sensor platform."""
     coordinator = config_entry.runtime_data
-    envoy_data = coordinator.envoy.data
+    envoy = coordinator.envoy
+    assert envoy is not None
+    envoy_data = envoy.data
     assert envoy_data is not None
     _LOGGER.debug("Envoy data: %s", envoy_data)
 
     entities: list[Entity] = [
         EnvoyProductionEntity(coordinator, description)
         for description in PRODUCTION_SENSORS
     ]
-    if envoy_data.system_consumption:
+    # add unconditionally if TOTAL_CONSUMPTION is available to overcome
+    # None value at startup caused by envoy fw issues
+    if envoy.supported_features & SupportedFeatures.TOTAL_CONSUMPTION:
         entities.extend(
             EnvoyConsumptionEntity(coordinator, description)
             for description in CONSUMPTION_SENSORS
         )
-    if envoy_data.system_net_consumption:
+    # add unconditionally if NET_CONSUMPTION is available to overcome
+    # None value at startup caused by envoy fw issues
+    if envoy.supported_features & SupportedFeatures.NET_CONSUMPTION:
         entities.extend(
             EnvoyNetConsumptionEntity(coordinator, description)
             for description in NET_CONSUMPTION_SENSORS
         )
     # For each production phase reported add production entities
-    if envoy_data.system_production_phases:
+    # if PRODUCTION is available and phases detected even if None
+    # to overcome None value at startup caused by envoy fw issues
+    if envoy.active_phase_count and (
+        envoy.supported_features & SupportedFeatures.PRODUCTION
+    ):
         entities.extend(
             EnvoyProductionPhaseEntity(coordinator, description)
-            for use_phase, phase in envoy_data.system_production_phases.items()
+            for index, use_phase in enumerate(PHASENAMES)
             for description in PRODUCTION_PHASE_SENSORS[use_phase]
-            if phase is not None
+            if index < (envoy.phase_count if envoy.phase_count > 1 else 0)
         )
     # For each consumption phase reported add consumption entities
-    if envoy_data.system_consumption_phases:
+    # if TOTAL_CONSUMPTION is available and phases detected even if None
+    # to overcome None value at startup caused by envoy fw issues
+    if (
+        envoy.active_phase_count
+        and envoy.phase_count > 1
+        and (envoy.supported_features & SupportedFeatures.TOTAL_CONSUMPTION)
+    ):
         entities.extend(
             EnvoyConsumptionPhaseEntity(coordinator, description)
-            for use_phase, phase in envoy_data.system_consumption_phases.items()
+            for index, use_phase in enumerate(PHASENAMES)
             for description in CONSUMPTION_PHASE_SENSORS[use_phase]
-            if phase is not None
+            if index < (envoy.phase_count if envoy.phase_count > 1 else 0)
         )
     # For each net_consumption phase reported add consumption entities
-    if envoy_data.system_net_consumption_phases:
+    # if NET_CONSUMPTION is available and phases detected even if None
+    # to overcome None value at startup caused by envoy fw issues
+    if envoy.active_phase_count and (
+        envoy.supported_features & SupportedFeatures.NET_CONSUMPTION
+    ):
         entities.extend(
             EnvoyNetConsumptionPhaseEntity(coordinator, description)
-            for use_phase, phase in envoy_data.system_net_consumption_phases.items()
+            for index, use_phase in enumerate(PHASENAMES)
             for description in NET_CONSUMPTION_PHASE_SENSORS[use_phase]
-            if phase is not None
+            if index < (envoy.phase_count if envoy.phase_count > 1 else 0)
         )
     # Add Current Transformer entities
     if envoy_data.ctmeters:
@@ -1181,8 +1203,8 @@ class EnvoyProductionEntity(EnvoySystemSensorEntity):
     @override
     def native_value(self) -> int | None:
         """Return the state of the sensor."""
-        system_production = self.data.system_production
-        assert system_production is not None
+        if (system_production := self.data.system_production) is None:
+            return None
         return self.entity_description.value_fn(system_production)
 
 
@@ -1195,8 +1217,8 @@ class EnvoyConsumptionEntity(EnvoySystemSensorEntity):
     @override
     def native_value(self) -> int | None:
         """Return the state of the sensor."""
-        system_consumption = self.data.system_consumption
-        assert system_consumption is not None
+        if (system_consumption := self.data.system_consumption) is None:
+            return None
         return self.entity_description.value_fn(system_consumption)
 
 
@@ -1209,8 +1231,8 @@ class EnvoyNetConsumptionEntity(EnvoySystemSensorEntity):
     @override
     def native_value(self) -> int | None:
         """Return the state of the sensor."""
-        system_net_consumption = self.data.system_net_consumption
-        assert system_net_consumption is not None
+        if (system_net_consumption := self.data.system_net_consumption) is None:
+            return None
         return self.entity_description.value_fn(system_net_consumption)
 
 
@@ -1225,8 +1247,11 @@ def native_value(self) -> int | None:
         """Return the state of the sensor."""
         if TYPE_CHECKING:
             assert self.entity_description.on_phase
-            assert self.data.system_production_phases
 
+        if self.data.system_production_phases is None:
+            return None
+        if self.entity_description.on_phase not in self.data.system_production_phases:
+            return None
         if (
             system_production := self.data.system_production_phases[
                 self.entity_description.on_phase
@@ -1247,8 +1272,11 @@ def native_value(self) -> int | None:
         """Return the state of the sensor."""
         if TYPE_CHECKING:
             assert self.entity_description.on_phase
-            assert self.data.system_consumption_phases
 
+        if self.data.system_consumption_phases is None:
+            return None
+        if self.entity_description.on_phase not in self.data.system_consumption_phases:
+            return None
         if (
             system_consumption := self.data.system_consumption_phases[
                 self.entity_description.on_phase
@@ -1269,8 +1297,14 @@ def native_value(self) -> int | None:
         """Return the state of the sensor."""
         if TYPE_CHECKING:
             assert self.entity_description.on_phase
-            assert self.data.system_net_consumption_phases
 
+        if self.data.system_net_consumption_phases is None:
+            return None
+        if (
+            self.entity_description.on_phase
+            not in self.data.system_net_consumption_phases
+        ):
+            return None
         if (
             system_net_consumption := self.data.system_net_consumption_phases[
                 self.entity_description.on_phase
@@ -1293,6 +1327,8 @@ def native_value(
         """Return the state of the CT sensor."""
         if (cttype := self.entity_description.cttype) not in self.data.ctmeters:
             return None
+        if self.data.ctmeters[cttype] is None:
+            return None
         return self.entity_description.value_fn(self.data.ctmeters[cttype])
 
 
@@ -1315,6 +1351,8 @@ def native_value(
             cttype
         ]:
             return None
+        if self.data.ctmeters_phases[cttype][phase] is None:
+            return None
         return self.entity_description.value_fn(
             self.data.ctmeters_phases[cttype][phase]
         )

homeassistant/components/fyta/coordinator.py

@@ -1,7 +1,7 @@
 """Coordinator for FYTA integration."""
 
 from collections.abc import Callable
-from datetime import datetime, timedelta
+from datetime import timedelta
 import logging
 from typing import override
 
@@ -20,6 +20,7 @@
 from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+from homeassistant.util import dt as dt_util
 
 from .const import CONF_EXPIRATION, DOMAIN
 
@@ -54,10 +55,7 @@ async def _async_update_data(
     ) -> dict[int, Plant]:
         """Fetch data from API endpoint."""
 
-        if (
-            self.fyta.expiration is None
-            or self.fyta.expiration.timestamp() < datetime.now().timestamp()  # pylint: disable=home-assistant-enforce-naive-now
-        ):
+        if self.fyta.expiration is None or self.fyta.expiration < dt_util.now():
             await self.renew_authentication()
 
         try: