Fix analog output number losing its range, unit and name on the first read

tests/data/devices/digi-xbee3.json

@@ -505,7 +505,7 @@
         "native_value": null,
         "mode": "auto",
         "native_max_value": 1023.0,
-        "native_min_value": 0,
+        "native_min_value": 0.0,
         "native_step": 1.0,
         "native_unit_of_measurement": null
       },
@@ -531,7 +531,7 @@
         "native_value": null,
         "mode": "auto",
         "native_max_value": 1023.0,
-        "native_min_value": 0,
+        "native_min_value": 0.0,
         "native_step": 1.0,
         "native_unit_of_measurement": null
       }

tests/test_number.py

@@ -1,5 +1,6 @@
 """Test zha number platform."""
 
+import logging
 from unittest.mock import call
 
 import pytest
@@ -79,10 +80,17 @@ async def light_mock(zha_gateway: Gateway) -> ZigbeeDevice:
     return zigpy_device
 
 
+@pytest.mark.parametrize("cached", [True, False])
 async def test_number(
     zha_gateway: Gateway,
+    cached: bool,
+    caplog: pytest.LogCaptureFixture,
 ) -> None:
-    """Test zha number platform."""
+    """Test zha number platform.
+
+    Without a cached value, everything has to be read from the device, as on the
+    (re-)interview of a device.
+    """
     zigpy_analog_output_device = create_mock_zigpy_device(
         zha_gateway, ZIGPY_ANALOG_OUTPUT_DEVICE
     )
@@ -98,10 +106,13 @@ async def test_number(
         "engineering_units": 98,
         "application_type": 4 * 0x10000,
     }
-    update_attribute_cache(cluster)
+    if cached:
+        update_attribute_cache(cluster)
     cluster.PLUGGED_ATTR_READS["present_value"] = 15.0
 
+    caplog.set_level(logging.DEBUG, logger="zha.zigbee.cluster_config")
     zha_device = await join_zigpy_device(zha_gateway, zigpy_analog_output_device)
+    assert "Failed to read attributes" not in caplog.text
     # one for present_value and one for the rest configuration attributes
     assert cluster.read_attributes.call_count == 2
     attr_reads = set()
@@ -179,6 +190,101 @@ async def test_number(
     assert entity.state.native_value == 30.0
 
 
+async def test_number_capabilities_updated(
+    zha_gateway: Gateway,
+) -> None:
+    """Test the range, step and unit follow the device after the entity was added.
+
+    A device paired with an incomplete cache only gets the missing values later, e.g.
+    from the startup poll or a report.
+    """
+    zigpy_analog_output_device = create_mock_zigpy_device(
+        zha_gateway, ZIGPY_ANALOG_OUTPUT_DEVICE
+    )
+    cluster: general.AnalogOutput = zigpy_analog_output_device.endpoints.get(
+        1
+    ).analog_output
+    cluster.PLUGGED_ATTR_READS = {"min_present_value": 5.0, "present_value": 50.0}
+    update_attribute_cache(cluster)
+
+    zha_device = await join_zigpy_device(zha_gateway, zigpy_analog_output_device)
+    entity: PlatformEntity = get_entity(zha_device, platform=Platform.NUMBER)
+
+    assert entity.state.native_min_value == 5.0
+    assert entity.state.native_max_value == 1023
+    assert entity.state.native_step is None
+    assert entity.state.native_unit_of_measurement is None
+    assert entity.fallback_name is None
+
+    await send_attributes_report(
+        zha_gateway,
+        cluster,
+        {
+            "max_present_value": 100.0,
+            "resolution": 10.0,
+            "engineering_units": 98,
+            "description": "Power Limit",
+        },
+    )
+    await zha_gateway.async_block_till_done()
+
+    assert entity.state.native_min_value == 5.0
+    assert entity.state.native_max_value == 100.0
+    assert entity.state.native_step == 10.0
+    assert entity.state.native_unit_of_measurement == "%"
+    assert entity.fallback_name == "Power Limit"
+
+
+async def test_number_zero_max_value(
+    zha_gateway: Gateway,
+) -> None:
+    """Test a maximum of 0 is not replaced by the default."""
+    zigpy_analog_output_device = create_mock_zigpy_device(
+        zha_gateway, ZIGPY_ANALOG_OUTPUT_DEVICE
+    )
+    cluster: general.AnalogOutput = zigpy_analog_output_device.endpoints.get(
+        1
+    ).analog_output
+    cluster.PLUGGED_ATTR_READS = {
+        "min_present_value": -100.0,
+        "max_present_value": 0.0,
+        "present_value": -50.0,
+    }
+    update_attribute_cache(cluster)
+
+    zha_device = await join_zigpy_device(zha_gateway, zigpy_analog_output_device)
+    entity: PlatformEntity = get_entity(zha_device, platform=Platform.NUMBER)
+
+    assert entity.state.native_min_value == -100.0
+    assert entity.state.native_max_value == 0.0
+
+
+@pytest.mark.parametrize("resolution", [0.0, float("inf"), float("nan")])
+async def test_number_invalid_resolution(
+    zha_gateway: Gateway,
+    resolution: float,
+) -> None:
+    """Test an invalid resolution is not used as step."""
+    zigpy_analog_output_device = create_mock_zigpy_device(
+        zha_gateway, ZIGPY_ANALOG_OUTPUT_DEVICE
+    )
+    cluster: general.AnalogOutput = zigpy_analog_output_device.endpoints.get(
+        1
+    ).analog_output
+    cluster.PLUGGED_ATTR_READS = {
+        "min_present_value": 0.0,
+        "max_present_value": 1.0,
+        "resolution": resolution,
+        "present_value": 0.5,
+    }
+    update_attribute_cache(cluster)
+
+    zha_device = await join_zigpy_device(zha_gateway, zigpy_analog_output_device)
+    entity: PlatformEntity = get_entity(zha_device, platform=Platform.NUMBER)
+
+    assert entity.state.native_step is None
+
+
 async def test_number_missing_description_attr(
     zha_gateway: Gateway,
 ) -> None:

zha/application/platforms/number/__init__.py

@@ -4,8 +4,8 @@
 
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
-import functools
 import logging
+import math
 from typing import TYPE_CHECKING, Any
 
 from zigpy.zcl import (
@@ -110,12 +110,12 @@ def native_step(self) -> float | None:
         """Return the value step."""
         return self._attr_native_step
 
-    @functools.cached_property
+    @property
     def native_unit_of_measurement(self) -> str | None:
         """Return the unit the value is expressed in."""
         return self._attr_native_unit_of_measurement
 
-    @functools.cached_property
+    @property
     def mode(self) -> NumberMode:
         """Return the mode of the entity."""
         return self._attr_mode
@@ -168,17 +168,38 @@ class AnalogOutputNumber(BaseNumber):
         ),
     }
 
+    _capability_attribute_ids = frozenset(
+        {
+            AnalogOutput.AttributeDefs.min_present_value.id,
+            AnalogOutput.AttributeDefs.max_present_value.id,
+            AnalogOutput.AttributeDefs.resolution.id,
+            AnalogOutput.AttributeDefs.description.id,
+            AnalogOutput.AttributeDefs.engineering_units.id,
+            AnalogOutput.AttributeDefs.application_type.id,
+        }
+    )
+
+    def __init__(self, endpoint: Endpoint, device: Device, **kwargs: Any) -> None:
+        """Init this number."""
+        super().__init__(endpoint=endpoint, device=device, **kwargs)
+        self.recompute_capabilities()
+
     def recompute_capabilities(self) -> None:
         """Recompute capabilities."""
         super().recompute_capabilities()
 
         min_val = self._cluster.get(AnalogOutput.AttributeDefs.min_present_value.name)
         max_val = self._cluster.get(AnalogOutput.AttributeDefs.max_present_value.name)
-        self._attr_native_min_value = min_val or 0
-        self._attr_native_max_value = max_val or 1023
-        self._attr_native_step = self._cluster.get(
-            AnalogOutput.AttributeDefs.resolution.name
-        )
+        self._attr_native_min_value = 0 if min_val is None else min_val
+        self._attr_native_max_value = 1023 if max_val is None else max_val
+
+        # Guard against 0 resolution reported by some devices
+        resolution = self._cluster.get(AnalogOutput.AttributeDefs.resolution.name)
+        if resolution is not None and math.isfinite(resolution) and resolution > 0:
+            self._attr_native_step = resolution
+        else:
+            self._attr_native_step = None
+
         self._attr_native_unit_of_measurement = BACNET_UNITS_TO_HA_UNITS.get(
             self._cluster.get(AnalogOutput.AttributeDefs.engineering_units.name)
         )
@@ -241,6 +262,8 @@ def handle_attribute_updated(
         | AttributeWrittenEvent,
     ) -> None:
         """Handle value update from cluster."""
+        if event.attribute_id in self._capability_attribute_ids:
+            self.recompute_capabilities()
         self.maybe_emit_state_changed_event()