Avoid circular import in Storage.async_delay_save (#111086)

homeassistant/helpers/storage.py

@@ -108,7 +108,7 @@ class Store(Generic[_T]):
         self.hass = hass
         self._private = private
         self._data: dict[str, Any] | None = None
-        self._unsub_delay_listener: CALLBACK_TYPE | None = None
+        self._unsub_delay_listener: asyncio.TimerHandle | None = None
         self._unsub_final_write_listener: CALLBACK_TYPE | None = None
         self._write_lock = asyncio.Lock()
         self._load_task: asyncio.Future[_T | None] | None = None
@@ -279,9 +279,6 @@ class Store(Generic[_T]):
         delay: float = 0,
     ) -> None:
         """Save data with an optional delay."""
-        # pylint: disable-next=import-outside-toplevel
-        from .event import async_call_later
-
         self._data = {
             "version": self.version,
             "minor_version": self.minor_version,
@@ -295,10 +292,16 @@ class Store(Generic[_T]):
         if self.hass.state is CoreState.stopping:
             return
 
-        self._unsub_delay_listener = async_call_later(
-            self.hass, delay, self._async_callback_delayed_write
+        # We use call_later directly here to avoid a circular import
+        self._unsub_delay_listener = self.hass.loop.call_later(
+            delay, self._async_schedule_callback_delayed_write
         )
 
+    @callback
+    def _async_schedule_callback_delayed_write(self) -> None:
+        """Schedule the delayed write in a task."""
+        self.hass.async_create_task(self._async_callback_delayed_write())
+
     @callback
     def _async_ensure_final_write_listener(self) -> None:
         """Ensure that we write if we quit before delay has passed."""
@@ -318,10 +321,10 @@ class Store(Generic[_T]):
     def _async_cleanup_delay_listener(self) -> None:
         """Clean up a delay listener."""
         if self._unsub_delay_listener is not None:
-            self._unsub_delay_listener()
+            self._unsub_delay_listener.cancel()
             self._unsub_delay_listener = None
 
-    async def _async_callback_delayed_write(self, _now):
+    async def _async_callback_delayed_write(self) -> None:
         """Handle a delayed write callback."""
         # catch the case where a call is scheduled and then we stop Home Assistant
         if self.hass.state is CoreState.stopping: