Repository: home-assistant/core
File: homeassistant/components/tuya/models.py (Python)

Code before:
    def initialize_accumulated_value(self, device: CustomerDevice) -> None:
        """Initialize accumulated value from current device state.

        Called when the entity is added to Home Assistant.
        """
        if not self.is_delta_report:
            return

        raw_value = super().read_device_status(device)
        if raw_value is not None:
            self._accumulated_value = float(raw_value)
            _LOGGER.debug(
                "Initialized accumulated value from device for %s: %s",
                self.dpcode,
                self._accumulated_value,
            )

    def process_delta_update(
        self, device: CustomerDevice, dp_timestamps: dict | None = None
    ) -> None:
        """Process a delta update by accumulating the value.

        Called during state updates to accumulate incremental values.
        """
        if not self.is_delta_report:
            return

        current_timestamp = dp_timestamps.get(self.dpcode) if dp_timestamps else None

        # Skip duplicate updates with same timestamp
        if (
            current_timestamp is not None
            and current_timestamp == self._last_dp_timestamp
        ):
            _LOGGER.debug(
                "Skipping duplicate update for %s (same timestamp: %s)",
                self.dpcode,
                current_timestamp,
            )
            return

        raw_value = super().read_device_status(device)
        if raw_value is None:
            return

        delta = float(raw_value)

        if self._accumulated_value is None:
            self._accumulated_value = delta
            _LOGGER.debug(
                "Initialized accumulated value for %s: %s",

Review comment (suggestion):
is_delta_report is not needed if DPCodeDeltaIntegerWrapper is only used when report_type is sum

Code after:
    This wrapper handles sensors that report incremental (delta) values
    instead of cumulative totals. It accumulates the delta values locally
    to provide a running total.
    """

    _accumulated_value: float = 0
    _last_dp_timestamp: int | None = None

    def __init__(self, dpcode: str, type_information: IntegerTypeInformation) -> None:
        """Init DPCodeDeltaIntegerWrapper."""
        super().__init__(dpcode, type_information)
        # Delta reports use TOTAL_INCREASING state class
        self.state_class = SensorStateClass.TOTAL_INCREASING

    def skip_update(
        self,
        device: CustomerDevice,
        updated_status_properties: list[str] | None,
        dp_timestamps: dict[str, int] | None,
    ) -> bool:
        """Override skip_update to process delta updates.

        Processes delta accumulation before determining if update should be skipped.
        """
        if (
            super().skip_update(device, updated_status_properties, dp_timestamps)
            or dp_timestamps is None
            or (current_timestamp := dp_timestamps.get(self.dpcode)) is None
            or current_timestamp == self._last_dp_timestamp
            or (raw_value := super().read_device_status(device)) is None
        ):
            return True

        delta = float(raw_value)
        self._accumulated_value += delta
        _LOGGER.debug(
            "Delta update for %s: +%s, total: %s",
            self.dpcode,
            delta,
            self._accumulated_value,
        )

        self._last_dp_timestamp = current_timestamp
        return False

    def read_device_status(self, device: CustomerDevice) -> float | None:
        """Read device status, returning accumulated value for delta reports."""
        return self._accumulated_value


class DPCodeRawWrapper(DPCodeTypeInformationWrapper[RawTypeInformation]):