feat(sensor): round native values to cut recorder volume

Metric sensors previously reported full-precision rolling-average floats,
so the recorder wrote a new states row every publish cycle (zero dedup).
Round the value the recorder sees: loads / capacity-adjusted loads to 1
decimal, MHz (and max_mhz) to the nearest 50 MHz; epp/epb pass through.
MHz uses a step rather than decimals because the value is a 4-digit
average that wanders tens of MHz per cycle, so decimal rounding never
dedupes and sub-50 MHz precision is noise.

Measured against ~2 days of production data this dedupes ~33% of
cpu_capacity states rows (15m windows compress most: mhz_15m -80%,
*_load_15m -42..49%; 1m windows resist by design). Affects states only,
not statistics. Load suggested_display_precision lowered 2 -> 1 so the
UI does not render a fake trailing digit.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: bakerkj

custom_components/cpu_capacity/sensor.py

@@ -60,7 +60,7 @@ def _build_descriptions(
                 native_unit_of_measurement=PERCENTAGE,
                 state_class=SensorStateClass.MEASUREMENT,
                 icon="mdi:gauge",
-                suggested_display_precision=2,
+                suggested_display_precision=1,
                 entity_registry_enabled_default=enabled_by_default,
             )
         )
@@ -74,7 +74,7 @@ def _build_descriptions(
                     native_unit_of_measurement=PERCENTAGE,
                     state_class=SensorStateClass.MEASUREMENT,
                     icon="mdi:speedometer",
-                    suggested_display_precision=2,
+                    suggested_display_precision=1,
                     entity_registry_enabled_default=enabled_by_default,
                 )
             )
@@ -154,6 +154,35 @@ def _round_summary_value(key: str, value: Any) -> Any:
     return value
 
 
+# Frequency is reported as a kHz-derived rolling average in the low thousands of
+# MHz; it wanders by tens of MHz every publish, so decimal rounding never lets
+# the recorder dedupe and sub-50 MHz precision is noise. Quantize to this step
+# instead.
+_MHZ_NATIVE_STEP = 50
+
+
+def _round_native_value(metric_key: str, value: Any) -> Any:
+    """Round the value the recorder sees so unchanged samples are deduped.
+
+    Loads keep one decimal (sub-percent detail on the responsive 1m windows is
+    preserved); MHz is quantized to ``_MHZ_NATIVE_STEP``. Non-numeric metrics
+    (``epp`` string, ``epb`` integer) pass through unchanged.
+    """
+    if value is None or isinstance(value, bool):
+        return value
+    if not isinstance(value, (int, float)):
+        return value
+
+    number = float(value)
+    if metric_key == "max_mhz" or metric_key.startswith("mhz_"):
+        return int(round(number / _MHZ_NATIVE_STEP) * _MHZ_NATIVE_STEP)
+    if metric_key.startswith("load_pct_") or metric_key.startswith(
+        "capacity_adjusted_load_pct_"
+    ):
+        return round(number, 1)
+    return value
+
+
 class CpuCapacityBaseSensor(CoordinatorEntity[CpuCapacityCoordinator], SensorEntity):
     _attr_has_entity_name = True
     _attr_should_poll = False
@@ -198,7 +227,10 @@ def native_value(self) -> Any:
         cpu_data = self._cpu_data
         if cpu_data is None:
             return None
-        return cpu_data.get(self.entity_description.metric_key)
+        return _round_native_value(
+            self.entity_description.metric_key,
+            cpu_data.get(self.entity_description.metric_key),
+        )
 
     @property
     def available(self) -> bool: