Repair storage datetime (#4576)

Author: andrew-codechimp

custom_components/battery_notes/binary_sensor.py

@@ -52,11 +52,9 @@
     Template,
     TemplateStateFromEntityId,
 )
+from homeassistant.util import dt as dt_util
 
-from .common import (
-    utcnow_no_timezone,
-    validate_is_float,
-)
+from .common import validate_is_float
 from .const import (
     ATTR_BATTERY_LAST_REPLACED,
     ATTR_BATTERY_LOW_THRESHOLD,
@@ -610,7 +608,7 @@ async def async_state_changed_listener(
             self.async_write_ha_state()
             return
 
-        self.coordinator.last_reported = utcnow_no_timezone()
+        self.coordinator.last_reported = dt_util.utcnow()
         self.coordinator.battery_low_binary_state = (
             wrapped_battery_low_state.state == "on"
         )

custom_components/battery_notes/button.py

@@ -19,8 +19,8 @@
 )
 from homeassistant.helpers.entity import EntityCategory
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.util import dt as dt_util
 
-from .common import utcnow_no_timezone
 from .const import (
     ATTR_BATTERY_QUANTITY,
     ATTR_BATTERY_TYPE,
@@ -146,7 +146,7 @@ async def async_added_to_hass(self) -> None:
 
     async def async_press(self) -> None:
         """Press the button."""
-        self.coordinator.last_replaced = utcnow_no_timezone()
+        self.coordinator.last_replaced = dt_util.utcnow()
 
         self.hass.bus.async_fire(
             EVENT_BATTERY_REPLACED,

custom_components/battery_notes/common.py

@@ -1,10 +1,6 @@
 """Common functions for battery_notes."""
 
-import re
-from datetime import datetime
-
 from homeassistant.helpers.device_registry import DeviceEntry
-from homeassistant.util import dt as dt_util
 
 
 def validate_is_float(num):
@@ -18,35 +14,6 @@ def validate_is_float(num):
     return False
 
 
-def utcnow_no_timezone() -> datetime:
-    """Return UTC now without timezone information."""
-
-    return dt_util.utcnow().replace(tzinfo=None)
-
-
-def fix_datetime_string(datetime_str) -> str:
-    """Fix datetime string by replacing colon with period before microseconds."""
-    # Prior to 3.3.2 there was an issue where microseconds were formatted with a colon and are held in storage.
-    # New dates are stored correctly, over time the last_reported, last_replaced will be updated with the correct format.
-
-    # Look for timezone offset at the end (e.g., +00:00, -05:00, Z)
-    tz_match = re.search(r"([+-]\d{2}:\d{2}|[+-]\d{4}|Z)$", datetime_str)
-
-    if tz_match:
-        # Split into datetime and timezone parts
-        tz_start = tz_match.start()
-        datetime_part = datetime_str[:tz_start]
-        tz_part = datetime_str[tz_start:]
-    else:
-        datetime_part = datetime_str
-        tz_part = ""
-
-    # Replace colon with period only if followed by exactly 6 digits (microseconds)
-    datetime_part = re.sub(r":(\d{6})$", r".\1", datetime_part)
-
-    return datetime_part + tz_part
-
-
 def get_device_model_id(device_entry: DeviceEntry) -> str | None:
     """Get the device model if available."""
     return device_entry.model_id if hasattr(device_entry, "model_id") else None

custom_components/battery_notes/coordinator.py

@@ -27,9 +27,10 @@
 )
 from homeassistant.helpers.entity_registry import RegistryEntry
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
+from homeassistant.util import dt as dt_util
 from homeassistant.util.hass_dict import HassKey
 
-from .common import fix_datetime_string, utcnow_no_timezone, validate_is_float
+from .common import validate_is_float
 from .const import (
     ATTR_BATTERY_LAST_REPLACED,
     ATTR_BATTERY_LEVEL,
@@ -116,9 +117,7 @@ class BatteryNotesSubentryCoordinator(DataUpdateCoordinator[None]):
     wrapped_battery: RegistryEntry | None = None
     wrapped_battery_low: RegistryEntry | None = None
     is_orphaned: bool = False
-    last_wrapped_battery_state_write: datetime = utcnow_no_timezone() - timedelta(
-        hours=2
-    )
+    last_wrapped_battery_state_write: datetime = dt_util.utcnow() - timedelta(hours=2)
     _current_battery_level: str | None = None
     _previous_battery_low: bool | None = None
     _previous_battery_level: str | None = None
@@ -195,13 +194,11 @@ def __init__(  # noqa: PLR0912
                 device_entry = device_registry.async_get(self.device_id)
 
                 if device_entry and device_entry.created_at.year > 1970:
-                    last_replaced = device_entry.created_at.strftime(
-                        "%Y-%m-%dT%H:%M:%S.%f"
-                    )
+                    last_replaced = device_entry.created_at
             elif self.source_entity_id:
                 entity = entity_registry.async_get(self.source_entity_id)
                 if entity and entity.created_at.year > 1970:
-                    last_replaced = entity.created_at.strftime("%Y-%m-%dT%H:%M:%S.%f")
+                    last_replaced = entity.created_at
 
             _LOGGER.debug(
                 "Defaulting %s battery last replaced to %s",
@@ -210,11 +207,11 @@ def __init__(  # noqa: PLR0912
             )
 
             if last_replaced:
-                self.last_replaced = datetime.fromisoformat(last_replaced)
+                self.last_replaced = last_replaced
 
         # If there is not a last_reported set to now
         if not self.last_reported:
-            last_reported = utcnow_no_timezone()
+            last_reported = dt_util.utcnow()
             _LOGGER.debug(
                 "Defaulting %s battery last reported to %s",
                 self.source_entity_id or self.device_id,
@@ -617,7 +614,7 @@ def current_battery_level(self, value):
                     _LOGGER.debug("battery_increased event fired")
 
         if self._current_battery_level not in [STATE_UNAVAILABLE, STATE_UNKNOWN]:
-            self.last_reported = utcnow_no_timezone()
+            self.last_reported = dt_util.utcnow()
             self.last_reported_level = cast(float, self._current_battery_level)
             self._previous_battery_low = self.battery_low
             self._previous_battery_level = self._current_battery_level
@@ -647,15 +644,7 @@ def last_replaced(self) -> datetime | None:
             )
 
         if entry and LAST_REPLACED in entry and entry[LAST_REPLACED] is not None:
-            entry_last_replaced = str(entry[LAST_REPLACED])
-            if not entry_last_replaced.endswith("+00:00"):
-                entry_last_replaced += "+00:00"
-
-            try:
-                return datetime.fromisoformat(entry_last_replaced)
-            except ValueError:
-                entry_last_replaced = fix_datetime_string(entry_last_replaced)
-                return datetime.fromisoformat(entry_last_replaced)
+            return datetime.fromisoformat(str(entry[LAST_REPLACED]))
         return None
 
     @last_replaced.setter
@@ -688,20 +677,12 @@ def last_reported(self) -> datetime | None:
             )
 
         if entry and LAST_REPORTED in entry and entry[LAST_REPORTED] is not None:
-            entry_last_reported = str(entry[LAST_REPORTED])
-            if not entry_last_reported.endswith("+00:00"):
-                entry_last_reported += "+00:00"
-
-            try:
-                return datetime.fromisoformat(entry_last_reported)
-            except ValueError:
-                entry_last_reported = fix_datetime_string(entry_last_reported)
-                return datetime.fromisoformat(entry_last_reported)
+            return datetime.fromisoformat(str(entry[LAST_REPORTED]))
 
         return None
 
     @last_reported.setter
-    def last_reported(self, value):
+    def last_reported(self, value: datetime):
         """Set the last reported datetime and store it."""
 
         if not hasattr(self.config_entry, "runtime_data"):

custom_components/battery_notes/filters.py

@@ -7,7 +7,8 @@
 from numbers import Number
 from typing import cast
 
-from .common import utcnow_no_timezone
+from homeassistant.util import dt as dt_util
+
 from .const import WINDOW_SIZE_UNIT_NUMBER_EVENTS, WINDOW_SIZE_UNIT_TIME
 
 _LOGGER = logging.getLogger(__name__)
@@ -20,7 +21,7 @@ class FilterState:
 
     def __init__(self, state: str | float | int) -> None:
         """Initialize with HA State object."""
-        self.timestamp = utcnow_no_timezone()
+        self.timestamp = dt_util.utcnow()
         try:
             self.state = float(state)
         except ValueError:

custom_components/battery_notes/sensor.py

@@ -53,8 +53,9 @@
     TemplateStateFromEntityId,
 )
 from homeassistant.helpers.typing import StateType
+from homeassistant.util import dt as dt_util
 
-from .common import utcnow_no_timezone, validate_is_float
+from .common import validate_is_float
 from .const import (
     ATTR_BATTERY_LAST_REPLACED,
     ATTR_BATTERY_LAST_REPORTED,
@@ -560,20 +561,20 @@ async def async_state_reported_listener(
             return
 
         # Don't update if battery level same and it's been < 1 hour
-        delta = utcnow_no_timezone() - self.coordinator.last_wrapped_battery_state_write
+        delta = dt_util.utcnow() - self.coordinator.last_wrapped_battery_state_write
         if (
             self.coordinator.last_reported_level == wrapped_battery_state.state
             and delta.total_seconds() < 3600  # 1 hour
         ):
             self._attr_available = True
             return
 
-        self.coordinator.last_wrapped_battery_state_write = utcnow_no_timezone()
+        self.coordinator.last_wrapped_battery_state_write = dt_util.utcnow()
         self.coordinator.current_battery_level = wrapped_battery_state.state
 
         await self.coordinator.async_request_refresh()
 
-        self.coordinator.last_reported = utcnow_no_timezone()
+        self.coordinator.last_reported = dt_util.utcnow()
 
         _LOGGER.debug(
             "Entity id %s has been reported.",

custom_components/battery_notes/services.py

@@ -1,7 +1,6 @@
 """Define services for the Battery Notes integration."""
 
 import logging
-from datetime import datetime
 from typing import Any, cast
 
 from homeassistant.core import (
@@ -15,7 +14,6 @@
 from homeassistant.helpers import device_registry as dr, entity_registry as er
 from homeassistant.util import dt as dt_util
 
-from .common import utcnow_no_timezone
 from .const import (
     ATTR_BATTERY_LAST_REPLACED,
     ATTR_BATTERY_LAST_REPLACED_DAYS,
@@ -101,7 +99,7 @@ async def _async_battery_replaced(call: ServiceCall) -> ServiceResponse:  # noqa
     if datetime_replaced_entry:
         datetime_replaced = dt_util.as_utc(datetime_replaced_entry).replace(tzinfo=None)
     else:
-        datetime_replaced = utcnow_no_timezone()
+        datetime_replaced = dt_util.utcnow()
 
     entity_registry = er.async_get(call.hass)
     device_registry = dr.async_get(call.hass)
@@ -261,10 +259,7 @@ async def _async_battery_last_replaced(call: ServiceCall) -> ServiceResponse:
                     ):
                         continue
 
-                time_since_last_replaced = (
-                    datetime.fromisoformat(str(utcnow_no_timezone()) + "+00:00")
-                    - coordinator.last_replaced
-                )
+                time_since_last_replaced = dt_util.utcnow() - coordinator.last_replaced
 
                 if time_since_last_replaced.days > days_last_replaced:
                     if raise_events:
@@ -328,10 +323,7 @@ async def _async_battery_last_reported(call: ServiceCall) -> ServiceResponse:
             coordinator
         ) in battery_notes_config_entry.runtime_data.subentry_coordinators.values():
             if coordinator.wrapped_battery and coordinator.last_reported:
-                time_since_last_reported = (
-                    datetime.fromisoformat(str(utcnow_no_timezone()) + "+00:00")
-                    - coordinator.last_reported
-                )
+                time_since_last_reported = dt_util.utcnow() - coordinator.last_reported
                 if time_since_last_reported.days > days_last_reported:
                     if raise_events:
                         call.hass.bus.async_fire(

custom_components/battery_notes/store.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import logging
+import re
 from collections import OrderedDict
 from collections.abc import MutableMapping
 from datetime import datetime
@@ -15,14 +16,16 @@
 
 from .const import (
     DOMAIN,
+    LAST_REPLACED,
+    LAST_REPORTED,
 )
 
 _LOGGER = logging.getLogger(__name__)
 
 DATA_REGISTRY = f"{DOMAIN}_storage"
 STORAGE_KEY = f"{DOMAIN}.storage"
 STORAGE_VERSION_MAJOR = 1
-STORAGE_VERSION_MINOR = 0
+STORAGE_VERSION_MINOR = 2
 SAVE_DELAY = 10
 
 
@@ -48,21 +51,55 @@ class EntityEntry:
     battery_last_reported_level = attr.ib(type=float, default=None)
 
 
+def _fix_datetime_string(datetime_str: str) -> str:
+    """Fix datetime string by replacing colon with period before microseconds."""
+    # Prior to 3.3.2 there was an issue where microseconds were formatted with a colon and are held in storage.
+
+    # Look for timezone offset at the end (e.g., +00:00, -05:00, Z)
+    tz_match = re.search(r"([+-]\d{2}:\d{2}|[+-]\d{4}|Z)$", datetime_str)
+
+    if tz_match:
+        # Split into datetime and timezone parts
+        tz_start = tz_match.start()
+        datetime_part = datetime_str[:tz_start]
+        tz_part = datetime_str[tz_start:]
+    else:
+        datetime_part = datetime_str
+        tz_part = "+00:00"
+
+    # Replace colon with period only if followed by exactly 6 digits (microseconds)
+    datetime_part = re.sub(r":(\d{6})$", r".\1", datetime_part)
+
+    return datetime_part + tz_part
+
+
 class MigratableStore(Store):
     """Holds battery notes data."""
 
     async def _async_migrate_func(
         self,
-        old_major_version: int,  # noqa: ARG002
-        old_minor_version: int,  # noqa: ARG002
+        old_major_version: int,
+        old_minor_version: int,
         data: dict,
     ):
-        # pylint: disable=arguments-renamed
-        # pylint: disable=unused-argument
-
-        # if old_major_version == 1:
-        # Do nothing for now
-
+        if old_major_version == 1:
+            if old_minor_version < 2:
+                for device in data["devices"]:
+                    last_replaced = device[LAST_REPLACED]
+                    if last_replaced:
+                        device[LAST_REPLACED] = _fix_datetime_string(last_replaced)
+
+                    last_reported = device[LAST_REPORTED]
+                    if last_reported:
+                        device[LAST_REPORTED] = _fix_datetime_string(last_reported)
+                for entity in data["entities"]:
+                    last_replaced = entity[LAST_REPLACED]
+                    if last_replaced:
+                        entity[LAST_REPLACED] = _fix_datetime_string(last_replaced)
+
+                    last_reported = entity[LAST_REPORTED]
+                    if last_reported:
+                        entity[LAST_REPORTED] = _fix_datetime_string(last_reported)
         return data