esphome 2025.9.2__py3-none-any.whl → 2025.10.0b1__py3-none-any.whl

esphome/core/scheduler.cpp

@@ -118,7 +118,6 @@ void HOT Scheduler::set_timer_common_(Component *component, SchedulerItem::Type
   item->type = type;
   item->callback = std::move(func);
   // Initialize remove to false (though it should already be from constructor)
-  // Not using mark_item_removed_ helper since we're setting to false, not true
 #ifdef ESPHOME_THREAD_MULTI_ATOMICS
   item->remove.store(false, std::memory_order_relaxed);
 #else
@@ -600,12 +599,7 @@ bool HOT Scheduler::cancel_item_locked_(Component *component, const char *name_c
 #ifndef ESPHOME_THREAD_SINGLE
   // Mark items in defer queue as cancelled (they'll be skipped when processed)
   if (type == SchedulerItem::TIMEOUT) {
-    for (auto &item : this->defer_queue_) {
-      if (this->matches_item_(item, component, name_cstr, type, match_retry)) {
-        this->mark_item_removed_(item.get());
-        total_cancelled++;
-      }
-    }
+    total_cancelled += this->mark_matching_items_removed_(this->defer_queue_, component, name_cstr, type, match_retry);
   }
 #endif /* not ESPHOME_THREAD_SINGLE */
 
@@ -620,23 +614,13 @@ bool HOT Scheduler::cancel_item_locked_(Component *component, const char *name_c
       total_cancelled++;
     }
     // For other items in heap, we can only mark for removal (can't remove from middle of heap)
-    for (auto &item : this->items_) {
-      if (this->matches_item_(item, component, name_cstr, type, match_retry)) {
-        this->mark_item_removed_(item.get());
-        total_cancelled++;
-        this->to_remove_++;  // Track removals for heap items
-      }
-    }
+    size_t heap_cancelled = this->mark_matching_items_removed_(this->items_, component, name_cstr, type, match_retry);
+    total_cancelled += heap_cancelled;
+    this->to_remove_ += heap_cancelled;  // Track removals for heap items
   }
 
   // Cancel items in to_add_
-  for (auto &item : this->to_add_) {
-    if (this->matches_item_(item, component, name_cstr, type, match_retry)) {
-      this->mark_item_removed_(item.get());
-      total_cancelled++;
-      // Don't track removals for to_add_ items
-    }
-  }
+  total_cancelled += this->mark_matching_items_removed_(this->to_add_, component, name_cstr, type, match_retry);
 
   return total_cancelled > 0;
 }

esphome/core/scheduler.h

@@ -280,19 +280,30 @@ class Scheduler {
 #endif
   }
 
-  // Helper to mark item for removal (platform-specific)
+  // Helper to mark matching items in a container as removed
+  // Returns the number of items marked for removal
   // For ESPHOME_THREAD_MULTI_NO_ATOMICS platforms, the caller must hold the scheduler lock before calling this
   // function.
-  void mark_item_removed_(SchedulerItem *item) {
+  template<typename Container>
+  size_t mark_matching_items_removed_(Container &container, Component *component, const char *name_cstr,
+                                      SchedulerItem::Type type, bool match_retry) {
+    size_t count = 0;
+    for (auto &item : container) {
+      if (this->matches_item_(item, component, name_cstr, type, match_retry)) {
+        // Mark item for removal (platform-specific)
 #ifdef ESPHOME_THREAD_MULTI_ATOMICS
-    // Multi-threaded with atomics: use atomic store
-    item->remove.store(true, std::memory_order_release);
+        // Multi-threaded with atomics: use atomic store
+        item->remove.store(true, std::memory_order_release);
 #else
-    // Single-threaded (ESPHOME_THREAD_SINGLE) or
-    // multi-threaded without atomics (ESPHOME_THREAD_MULTI_NO_ATOMICS): direct write
-    // For ESPHOME_THREAD_MULTI_NO_ATOMICS, caller MUST hold lock!
-    item->remove = true;
+        // Single-threaded (ESPHOME_THREAD_SINGLE) or
+        // multi-threaded without atomics (ESPHOME_THREAD_MULTI_NO_ATOMICS): direct write
+        // For ESPHOME_THREAD_MULTI_NO_ATOMICS, caller MUST hold lock!
+        item->remove = true;
 #endif
+        count++;
+      }
+    }
+    return count;
   }
 
   // Template helper to check if any item in a container matches our criteria

esphome/core/string_ref.h

@@ -130,7 +130,7 @@ inline std::string operator+(const StringRef &lhs, const char *rhs) {
 
 #ifdef USE_JSON
 // NOLINTNEXTLINE(readability-identifier-naming)
-void convertToJson(const StringRef &src, JsonVariant dst);
+inline void convertToJson(const StringRef &src, JsonVariant dst) { dst.set(src.c_str()); }
 #endif  // USE_JSON
 
 }  // namespace esphome

esphome/core/time.cpp

@@ -77,7 +77,7 @@ bool ESPTime::strptime(const std::string &time_to_parse, ESPTime &esp_time) {
              &hour,                                                                                      // NOLINT
              &minute,                                                                                    // NOLINT
              &second, &num) == 6 &&                                                                      // NOLINT
-      num == time_to_parse.size()) {
+      num == static_cast<int>(time_to_parse.size())) {
     esp_time.year = year;
     esp_time.month = month;
     esp_time.day_of_month = day;
@@ -87,7 +87,7 @@ bool ESPTime::strptime(const std::string &time_to_parse, ESPTime &esp_time) {
   } else if (sscanf(time_to_parse.c_str(), "%04hu-%02hhu-%02hhu %02hhu:%02hhu %n", &year, &month, &day,  // NOLINT
                     &hour,                                                                               // NOLINT
                     &minute, &num) == 5 &&                                                               // NOLINT
-             num == time_to_parse.size()) {
+             num == static_cast<int>(time_to_parse.size())) {
     esp_time.year = year;
     esp_time.month = month;
     esp_time.day_of_month = day;
@@ -95,17 +95,17 @@ bool ESPTime::strptime(const std::string &time_to_parse, ESPTime &esp_time) {
     esp_time.minute = minute;
     esp_time.second = 0;
   } else if (sscanf(time_to_parse.c_str(), "%02hhu:%02hhu:%02hhu %n", &hour, &minute, &second, &num) == 3 &&  // NOLINT
-             num == time_to_parse.size()) {
+             num == static_cast<int>(time_to_parse.size())) {
     esp_time.hour = hour;
     esp_time.minute = minute;
     esp_time.second = second;
   } else if (sscanf(time_to_parse.c_str(), "%02hhu:%02hhu %n", &hour, &minute, &num) == 2 &&  // NOLINT
-             num == time_to_parse.size()) {
+             num == static_cast<int>(time_to_parse.size())) {
     esp_time.hour = hour;
     esp_time.minute = minute;
     esp_time.second = 0;
   } else if (sscanf(time_to_parse.c_str(), "%04hu-%02hhu-%02hhu %n", &year, &month, &day, &num) == 3 &&  // NOLINT
-             num == time_to_parse.size()) {
+             num == static_cast<int>(time_to_parse.size())) {
     esp_time.year = year;
     esp_time.month = month;
     esp_time.day_of_month = day;

esphome/cpp_generator.py

@@ -1,5 +1,5 @@
 import abc
-from collections.abc import Callable, Sequence
+from collections.abc import Callable
 import inspect
 import math
 import re
@@ -13,7 +13,6 @@ from esphome.core import (
     HexInt,
     Lambda,
     Library,
-    TimePeriod,
     TimePeriodMicroseconds,
     TimePeriodMilliseconds,
     TimePeriodMinutes,
@@ -21,35 +20,11 @@ from esphome.core import (
     TimePeriodSeconds,
 )
 from esphome.helpers import cpp_string_escape, indent_all_but_first_and_last
+from esphome.types import Expression, SafeExpType, TemplateArgsType
 from esphome.util import OrderedDict
 from esphome.yaml_util import ESPHomeDataBase
 
 
-class Expression(abc.ABC):
-    __slots__ = ()
-
-    @abc.abstractmethod
-    def __str__(self):
-        """
-        Convert expression into C++ code
-        """
-
-
-SafeExpType = (
-    Expression
-    | bool
-    | str
-    | str
-    | int
-    | float
-    | TimePeriod
-    | type[bool]
-    | type[int]
-    | type[float]
-    | Sequence[Any]
-)
-
-
 class RawExpression(Expression):
     __slots__ = ("text",)
 
@@ -575,7 +550,7 @@ def Pvariable(id_: ID, rhs: SafeExpType, type_: "MockObj" = None) -> "MockObj":
     return obj
 
 
-def new_Pvariable(id_: ID, *args: SafeExpType) -> Pvariable:
+def new_Pvariable(id_: ID, *args: SafeExpType) -> "MockObj":
     """Declare a new pointer variable in the code generation by calling it's constructor
     with the given arguments.
 
@@ -681,7 +656,7 @@ async def get_variable_with_full_id(id_: ID) -> tuple[ID, "MockObj"]:
 
 async def process_lambda(
     value: Lambda,
-    parameters: list[tuple[SafeExpType, str]],
+    parameters: TemplateArgsType,
     capture: str = "=",
     return_type: SafeExpType = None,
 ) -> LambdaExpression | None:

esphome/dashboard/const.py

@@ -1,9 +1,26 @@
 from __future__ import annotations
 
-EVENT_ENTRY_ADDED = "entry_added"
-EVENT_ENTRY_REMOVED = "entry_removed"
-EVENT_ENTRY_UPDATED = "entry_updated"
-EVENT_ENTRY_STATE_CHANGED = "entry_state_changed"
+from esphome.enum import StrEnum
+
+
+class DashboardEvent(StrEnum):
+    """Dashboard WebSocket event types."""
+
+    # Server -> Client events (backend sends to frontend)
+    ENTRY_ADDED = "entry_added"
+    ENTRY_REMOVED = "entry_removed"
+    ENTRY_UPDATED = "entry_updated"
+    ENTRY_STATE_CHANGED = "entry_state_changed"
+    IMPORTABLE_DEVICE_ADDED = "importable_device_added"
+    IMPORTABLE_DEVICE_REMOVED = "importable_device_removed"
+    INITIAL_STATE = "initial_state"  # Sent on WebSocket connection
+    PONG = "pong"  # Response to client ping
+
+    # Client -> Server events (frontend sends to backend)
+    PING = "ping"  # WebSocket keepalive from client
+    REFRESH = "refresh"  # Force backend to poll for changes
+
+
 MAX_EXECUTOR_WORKERS = 48
 
 

esphome/dashboard/core.py

@@ -7,13 +7,13 @@ from dataclasses import dataclass
 from functools import partial
 import json
 import logging
-from pathlib import Path
 import threading
 from typing import Any
 
 from esphome.storage_json import ignored_devices_storage_path
 
 from ..zeroconf import DiscoveredImport
+from .const import DashboardEvent
 from .dns import DNSCache
 from .entries import DashboardEntries
 from .settings import DashboardSettings
@@ -31,7 +31,7 @@ MDNS_BOOTSTRAP_TIME = 7.5
 class Event:
     """Dashboard Event."""
 
-    event_type: str
+    event_type: DashboardEvent
     data: dict[str, Any]
 
 
@@ -40,22 +40,24 @@ class EventBus:
 
     def __init__(self) -> None:
         """Initialize the Dashboard event bus."""
-        self._listeners: dict[str, set[Callable[[Event], None]]] = {}
+        self._listeners: dict[DashboardEvent, set[Callable[[Event], None]]] = {}
 
     def async_add_listener(
-        self, event_type: str, listener: Callable[[Event], None]
+        self, event_type: DashboardEvent, listener: Callable[[Event], None]
     ) -> Callable[[], None]:
         """Add a listener to the event bus."""
         self._listeners.setdefault(event_type, set()).add(listener)
         return partial(self._async_remove_listener, event_type, listener)
 
     def _async_remove_listener(
-        self, event_type: str, listener: Callable[[Event], None]
+        self, event_type: DashboardEvent, listener: Callable[[Event], None]
     ) -> None:
         """Remove a listener from the event bus."""
         self._listeners[event_type].discard(listener)
 
-    def async_fire(self, event_type: str, event_data: dict[str, Any]) -> None:
+    def async_fire(
+        self, event_type: DashboardEvent, event_data: dict[str, Any]
+    ) -> None:
         """Fire an event."""
         event = Event(event_type, event_data)
 
@@ -108,7 +110,7 @@ class ESPHomeDashboard:
         await self.loop.run_in_executor(None, self.load_ignored_devices)
 
     def load_ignored_devices(self) -> None:
-        storage_path = Path(ignored_devices_storage_path())
+        storage_path = ignored_devices_storage_path()
         try:
             with storage_path.open("r", encoding="utf-8") as f_handle:
                 data = json.load(f_handle)
@@ -117,7 +119,7 @@ class ESPHomeDashboard:
             pass
 
     def save_ignored_devices(self) -> None:
-        storage_path = Path(ignored_devices_storage_path())
+        storage_path = ignored_devices_storage_path()
         with storage_path.open("w", encoding="utf-8") as f_handle:
             json.dump(
                 {"ignored_devices": sorted(self.ignored_devices)}, indent=2, fp=f_handle

esphome/dashboard/dns.py

@@ -28,6 +28,21 @@ class DNSCache:
         self._cache: dict[str, tuple[float, list[str] | Exception]] = {}
         self._ttl = ttl
 
+    def get_cached_addresses(
+        self, hostname: str, now_monotonic: float
+    ) -> list[str] | None:
+        """Get cached addresses without triggering resolution.
+
+        Returns None if not in cache, list of addresses if found.
+        """
+        # Normalize hostname for consistent lookups
+        normalized = hostname.rstrip(".").lower()
+        if expire_time_addresses := self._cache.get(normalized):
+            expire_time, addresses = expire_time_addresses
+            if expire_time > now_monotonic and not isinstance(addresses, Exception):
+                return addresses
+        return None
+
     async def async_resolve(
         self, hostname: str, now_monotonic: float
     ) -> list[str] | Exception:

esphome/dashboard/entries.py

@@ -5,20 +5,14 @@ from collections import defaultdict
 from dataclasses import dataclass
 from functools import lru_cache
 import logging
-import os
+from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
 from esphome import const, util
 from esphome.enum import StrEnum
 from esphome.storage_json import StorageJSON, ext_storage_path
 
-from .const import (
-    DASHBOARD_COMMAND,
-    EVENT_ENTRY_ADDED,
-    EVENT_ENTRY_REMOVED,
-    EVENT_ENTRY_STATE_CHANGED,
-    EVENT_ENTRY_UPDATED,
-)
+from .const import DASHBOARD_COMMAND, DashboardEvent
 from .util.subprocess import async_run_system_command
 
 if TYPE_CHECKING:
@@ -102,12 +96,12 @@ class DashboardEntries:
         #   "path/to/file.yaml": DashboardEntry,
         #   ...
         # }
-        self._entries: dict[str, DashboardEntry] = {}
+        self._entries: dict[Path, DashboardEntry] = {}
         self._loaded_entries = False
         self._update_lock = asyncio.Lock()
         self._name_to_entry: dict[str, set[DashboardEntry]] = defaultdict(set)
 
-    def get(self, path: str) -> DashboardEntry | None:
+    def get(self, path: Path) -> DashboardEntry | None:
         """Get an entry by path."""
         return self._entries.get(path)
 
@@ -192,7 +186,7 @@ class DashboardEntries:
             return
         entry.state = state
         self._dashboard.bus.async_fire(
-            EVENT_ENTRY_STATE_CHANGED, {"entry": entry, "state": state}
+            DashboardEvent.ENTRY_STATE_CHANGED, {"entry": entry, "state": state}
         )
 
     async def async_request_update_entries(self) -> None:
@@ -260,22 +254,22 @@ class DashboardEntries:
         for entry in added:
             entries[entry.path] = entry
             name_to_entry[entry.name].add(entry)
-            bus.async_fire(EVENT_ENTRY_ADDED, {"entry": entry})
+            bus.async_fire(DashboardEvent.ENTRY_ADDED, {"entry": entry})
 
         for entry in removed:
             del entries[entry.path]
             name_to_entry[entry.name].discard(entry)
-            bus.async_fire(EVENT_ENTRY_REMOVED, {"entry": entry})
+            bus.async_fire(DashboardEvent.ENTRY_REMOVED, {"entry": entry})
 
         for entry in updated:
             if (original_name := original_names[entry]) != (current_name := entry.name):
                 name_to_entry[original_name].discard(entry)
                 name_to_entry[current_name].add(entry)
-            bus.async_fire(EVENT_ENTRY_UPDATED, {"entry": entry})
+            bus.async_fire(DashboardEvent.ENTRY_UPDATED, {"entry": entry})
 
-    def _get_path_to_cache_key(self) -> dict[str, DashboardCacheKeyType]:
+    def _get_path_to_cache_key(self) -> dict[Path, DashboardCacheKeyType]:
         """Return a dict of path to cache key."""
-        path_to_cache_key: dict[str, DashboardCacheKeyType] = {}
+        path_to_cache_key: dict[Path, DashboardCacheKeyType] = {}
         #
         # The cache key is (inode, device, mtime, size)
         # which allows us to avoid locking since it ensures
@@ -287,12 +281,12 @@ class DashboardEntries:
         for file in util.list_yaml_files([self._config_dir]):
             try:
                 # Prefer the json storage path if it exists
-                stat = os.stat(ext_storage_path(os.path.basename(file)))
+                stat = ext_storage_path(file.name).stat()
             except OSError:
                 try:
                     # Fallback to the yaml file if the storage
                     # file does not exist or could not be generated
-                    stat = os.stat(file)
+                    stat = file.stat()
                 except OSError:
                     # File was deleted, ignore
                     continue
@@ -329,10 +323,10 @@ class DashboardEntry:
         "_to_dict",
     )
 
-    def __init__(self, path: str, cache_key: DashboardCacheKeyType) -> None:
+    def __init__(self, path: Path, cache_key: DashboardCacheKeyType) -> None:
         """Initialize the DashboardEntry."""
         self.path = path
-        self.filename: str = os.path.basename(path)
+        self.filename: str = path.name
         self._storage_path = ext_storage_path(self.filename)
         self.cache_key = cache_key
         self.storage: StorageJSON | None = None
@@ -365,7 +359,7 @@ class DashboardEntry:
                 "loaded_integrations": sorted(self.loaded_integrations),
                 "deployed_version": self.update_old,
                 "current_version": self.update_new,
-                "path": self.path,
+                "path": str(self.path),
                 "comment": self.comment,
                 "address": self.address,
                 "web_port": self.web_port,

esphome/dashboard/models.py

@@ -0,0 +1,76 @@
+"""Data models and builders for the dashboard."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, TypedDict
+
+if TYPE_CHECKING:
+    from esphome.zeroconf import DiscoveredImport
+
+    from .core import ESPHomeDashboard
+    from .entries import DashboardEntry
+
+
+class ImportableDeviceDict(TypedDict):
+    """Dictionary representation of an importable device."""
+
+    name: str
+    friendly_name: str | None
+    package_import_url: str
+    project_name: str
+    project_version: str
+    network: str
+    ignored: bool
+
+
+class ConfiguredDeviceDict(TypedDict, total=False):
+    """Dictionary representation of a configured device."""
+
+    name: str
+    friendly_name: str | None
+    configuration: str
+    loaded_integrations: list[str] | None
+    deployed_version: str | None
+    current_version: str | None
+    path: str
+    comment: str | None
+    address: str | None
+    web_port: int | None
+    target_platform: str | None
+
+
+class DeviceListResponse(TypedDict):
+    """Response for device list API."""
+
+    configured: list[ConfiguredDeviceDict]
+    importable: list[ImportableDeviceDict]
+
+
+def build_importable_device_dict(
+    dashboard: ESPHomeDashboard, discovered: DiscoveredImport
+) -> ImportableDeviceDict:
+    """Build the importable device dictionary."""
+    return ImportableDeviceDict(
+        name=discovered.device_name,
+        friendly_name=discovered.friendly_name,
+        package_import_url=discovered.package_import_url,
+        project_name=discovered.project_name,
+        project_version=discovered.project_version,
+        network=discovered.network,
+        ignored=discovered.device_name in dashboard.ignored_devices,
+    )
+
+
+def build_device_list_response(
+    dashboard: ESPHomeDashboard, entries: list[DashboardEntry]
+) -> DeviceListResponse:
+    """Build the device list response data."""
+    configured = {entry.name for entry in entries}
+    return DeviceListResponse(
+        configured=[entry.to_dict() for entry in entries],
+        importable=[
+            build_importable_device_dict(dashboard, res)
+            for res in dashboard.import_result.values()
+            if res.device_name not in configured
+        ],
+    )

esphome/dashboard/settings.py

@@ -27,7 +27,7 @@ class DashboardSettings:
 
     def __init__(self) -> None:
         """Initialize the dashboard settings."""
-        self.config_dir: str = ""
+        self.config_dir: Path = None
         self.password_hash: str = ""
         self.username: str = ""
         self.using_password: bool = False
@@ -45,10 +45,10 @@ class DashboardSettings:
             self.using_password = bool(password)
         if self.using_password:
             self.password_hash = password_hash(password)
-        self.config_dir = args.configuration
-        self.absolute_config_dir = Path(self.config_dir).resolve()
+        self.config_dir = Path(args.configuration)
+        self.absolute_config_dir = self.config_dir.resolve()
         self.verbose = args.verbose
-        CORE.config_path = os.path.join(self.config_dir, ".")
+        CORE.config_path = self.config_dir / "."
 
     @property
     def relative_url(self) -> str:
@@ -81,9 +81,9 @@ class DashboardSettings:
         # Compare password in constant running time (to prevent timing attacks)
         return hmac.compare_digest(self.password_hash, password_hash(password))
 
-    def rel_path(self, *args: Any) -> str:
+    def rel_path(self, *args: Any) -> Path:
         """Return a path relative to the ESPHome config folder."""
-        joined_path = os.path.join(self.config_dir, *args)
+        joined_path = self.config_dir / Path(*args)
         # Raises ValueError if not relative to ESPHome config folder
-        Path(joined_path).resolve().relative_to(self.absolute_config_dir)
+        joined_path.resolve().relative_to(self.absolute_config_dir)
         return joined_path

esphome/dashboard/status/mdns.py

@@ -4,16 +4,21 @@ import asyncio
 import logging
 import typing
 
+from zeroconf import AddressResolver, IPVersion
+
+from esphome.address_cache import normalize_hostname
 from esphome.zeroconf import (
     ESPHOME_SERVICE_TYPE,
     AsyncEsphomeZeroconf,
     DashboardBrowser,
     DashboardImportDiscovery,
     DashboardStatus,
+    DiscoveredImport,
 )
 
-from ..const import SENTINEL
+from ..const import SENTINEL, DashboardEvent
 from ..entries import DashboardEntry, EntryStateSource, bool_to_entry_state
+from ..models import build_importable_device_dict
 
 if typing.TYPE_CHECKING:
     from ..core import ESPHomeDashboard
@@ -50,6 +55,44 @@ class MDNSStatus:
             return await aiozc.async_resolve_host(host_name)
         return None
 
+    def get_cached_addresses(self, host_name: str) -> list[str] | None:
+        """Get cached addresses for a host without triggering resolution.
+
+        Returns None if not in cache or no zeroconf available.
+        """
+        if not self.aiozc:
+            _LOGGER.debug("No zeroconf instance available for %s", host_name)
+            return None
+
+        # Normalize hostname and get the base name
+        normalized = normalize_hostname(host_name)
+        base_name = normalized.partition(".")[0]
+
+        # Try to load from zeroconf cache without triggering resolution
+        resolver_name = f"{base_name}.local."
+        info = AddressResolver(resolver_name)
+        # Let zeroconf use its own current time for cache checking
+        if info.load_from_cache(self.aiozc.zeroconf):
+            addresses = info.parsed_scoped_addresses(IPVersion.All)
+            _LOGGER.debug("Found %s in zeroconf cache: %s", resolver_name, addresses)
+            return addresses
+        _LOGGER.debug("Not found in zeroconf cache: %s", resolver_name)
+        return None
+
+    def _on_import_update(self, name: str, discovered: DiscoveredImport | None) -> None:
+        """Handle importable device updates."""
+        if discovered is None:
+            # Device removed
+            self.dashboard.bus.async_fire(
+                DashboardEvent.IMPORTABLE_DEVICE_REMOVED, {"name": name}
+            )
+        else:
+            # Device added
+            self.dashboard.bus.async_fire(
+                DashboardEvent.IMPORTABLE_DEVICE_ADDED,
+                {"device": build_importable_device_dict(self.dashboard, discovered)},
+            )
+
     async def async_refresh_hosts(self) -> None:
         """Refresh the hosts to track."""
         dashboard = self.dashboard
@@ -106,7 +149,8 @@ class MDNSStatus:
                         self._async_set_state(entry, result)
 
         stat = DashboardStatus(on_update)
-        imports = DashboardImportDiscovery()
+
+        imports = DashboardImportDiscovery(self._on_import_update)
         dashboard.import_result = imports.import_state
 
         browser = DashboardBrowser(