esphome 2025.8.3__py3-none-any.whl → 2025.9.0b1__py3-none-any.whl

esphome/helpers.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import codecs
 from contextlib import suppress
 import ipaddress
@@ -11,6 +13,18 @@ from urllib.parse import urlparse
 
 from esphome.const import __version__ as ESPHOME_VERSION
 
+# Type aliases for socket address information
+AddrInfo = tuple[
+    int,  # family (AF_INET, AF_INET6, etc.)
+    int,  # type (SOCK_STREAM, SOCK_DGRAM, etc.)
+    int,  # proto (IPPROTO_TCP, etc.)
+    str,  # canonname
+    tuple[str, int] | tuple[str, int, int, int],  # sockaddr (IPv4 or IPv6)
+]
+IPv4SockAddr = tuple[str, int]  # (host, port)
+IPv6SockAddr = tuple[str, int, int, int]  # (host, port, flowinfo, scope_id)
+SockAddr = IPv4SockAddr | IPv6SockAddr
+
 _LOGGER = logging.getLogger(__name__)
 
 IS_MACOS = platform.system() == "Darwin"
@@ -147,32 +161,7 @@ def is_ip_address(host):
         return False
 
 
-def _resolve_with_zeroconf(host):
-    from esphome.core import EsphomeError
-    from esphome.zeroconf import EsphomeZeroconf
-
-    try:
-        zc = EsphomeZeroconf()
-    except Exception as err:
-        raise EsphomeError(
-            "Cannot start mDNS sockets, is this a docker container without "
-            "host network mode?"
-        ) from err
-    try:
-        info = zc.resolve_host(f"{host}.")
-    except Exception as err:
-        raise EsphomeError(f"Error resolving mDNS hostname: {err}") from err
-    finally:
-        zc.close()
-    if info is None:
-        raise EsphomeError(
-            "Error resolving address with mDNS: Did not respond. "
-            "Maybe the device is offline."
-        )
-    return info
-
-
-def addr_preference_(res):
+def addr_preference_(res: AddrInfo) -> int:
     # Trivial alternative to RFC6724 sorting. Put sane IPv6 first, then
     # Legacy IP, then IPv6 link-local addresses without an actual link.
     sa = res[4]
@@ -184,66 +173,70 @@ def addr_preference_(res):
     return 1
 
 
-def resolve_ip_address(host, port):
+def resolve_ip_address(host: str | list[str], port: int) -> list[AddrInfo]:
     import socket
 
-    from esphome.core import EsphomeError
-
     # There are five cases here. The host argument could be one of:
     #  • a *list* of IP addresses discovered by MQTT,
     #  • a single IP address specified by the user,
     #  • a .local hostname to be resolved by mDNS,
     #  • a normal hostname to be resolved in DNS, or
     #  • A URL from which we should extract the hostname.
-    #
-    # In each of the first three cases, we end up with IP addresses in
-    # string form which need to be converted to a 5-tuple to be used
-    # for the socket connection attempt. The easiest way to construct
-    # those is to pass the IP address string to getaddrinfo(). Which,
-    # coincidentally, is how we do hostname lookups in the other cases
-    # too. So first build a list which contains either IP addresses or
-    # a single hostname, then call getaddrinfo() on each element of
-    # that list.
-
-    errs = []
+
+    hosts: list[str]
     if isinstance(host, list):
-        addr_list = host
-    elif is_ip_address(host):
-        addr_list = [host]
+        hosts = host
     else:
-        url = urlparse(host)
-        if url.scheme != "":
-            host = url.hostname
-
-        addr_list = []
-        if host.endswith(".local"):
+        if not is_ip_address(host):
+            url = urlparse(host)
+            if url.scheme != "":
+                host = url.hostname
+        hosts = [host]
+
+    res: list[AddrInfo] = []
+    if all(is_ip_address(h) for h in hosts):
+        # Fast path: all are IP addresses, use socket.getaddrinfo with AI_NUMERICHOST
+        for addr in hosts:
             try:
-                _LOGGER.info("Resolving IP address of %s in mDNS", host)
-                addr_list = _resolve_with_zeroconf(host)
-            except EsphomeError as err:
-                errs.append(str(err))
-
-        # If not mDNS, or if mDNS failed, use normal DNS
-        if not addr_list:
-            addr_list = [host]
-
-    # Now we have a list containing either IP addresses or a hostname
-    res = []
-    for addr in addr_list:
-        if not is_ip_address(addr):
-            _LOGGER.info("Resolving IP address of %s", host)
-        try:
-            r = socket.getaddrinfo(addr, port, proto=socket.IPPROTO_TCP)
-        except OSError as err:
-            errs.append(str(err))
-            raise EsphomeError(
-                f"Error resolving IP address: {', '.join(errs)}"
-            ) from err
-
-        res = res + r
+                res += socket.getaddrinfo(
+                    addr, port, proto=socket.IPPROTO_TCP, flags=socket.AI_NUMERICHOST
+                )
+            except OSError:
+                _LOGGER.debug("Failed to parse IP address '%s'", addr)
+        # Sort by preference
+        res.sort(key=addr_preference_)
+        return res
+
+    from esphome.resolver import AsyncResolver
+
+    resolver = AsyncResolver(hosts, port)
+    addr_infos = resolver.resolve()
+    # Convert aioesphomeapi AddrInfo to our format
+    for addr_info in addr_infos:
+        sockaddr = addr_info.sockaddr
+        if addr_info.family == socket.AF_INET6:
+            # IPv6
+            sockaddr_tuple = (
+                sockaddr.address,
+                sockaddr.port,
+                sockaddr.flowinfo,
+                sockaddr.scope_id,
+            )
+        else:
+            # IPv4
+            sockaddr_tuple = (sockaddr.address, sockaddr.port)
+
+        res.append(
+            (
+                addr_info.family,
+                addr_info.type,
+                addr_info.proto,
+                "",  # canonname
+                sockaddr_tuple,
+            )
+        )
 
-    # Zeroconf tends to give us link-local IPv6 addresses without specifying
-    # the link. Put those last in the list to be attempted.
+    # Sort by preference
     res.sort(key=addr_preference_)
     return res
 
@@ -262,15 +255,7 @@ def sort_ip_addresses(address_list: list[str]) -> list[str]:
 
     # First "resolve" all the IP addresses to getaddrinfo() tuples of the form
     # (family, type, proto, canonname, sockaddr)
-    res: list[
-        tuple[
-            int,
-            int,
-            int,
-            str | None,
-            tuple[str, int] | tuple[str, int, int, int],
-        ]
-    ] = []
+    res: list[AddrInfo] = []
     for addr in address_list:
         # This should always work as these are supposed to be IP addresses
         try:

esphome/resolver.py

@@ -0,0 +1,67 @@
+"""DNS resolver for ESPHome using aioesphomeapi."""
+
+from __future__ import annotations
+
+import asyncio
+import threading
+
+from aioesphomeapi.core import ResolveAPIError, ResolveTimeoutAPIError
+import aioesphomeapi.host_resolver as hr
+
+from esphome.core import EsphomeError
+
+RESOLVE_TIMEOUT = 10.0  # seconds
+
+
+class AsyncResolver(threading.Thread):
+    """Resolver using aioesphomeapi that runs in a thread for faster results.
+
+    This resolver uses aioesphomeapi's async_resolve_host to handle DNS resolution,
+    including proper .local domain fallback. Running in a thread allows us to get
+    the result immediately without waiting for asyncio.run() to complete its
+    cleanup cycle, which can take significant time.
+    """
+
+    def __init__(self, hosts: list[str], port: int) -> None:
+        """Initialize the resolver."""
+        super().__init__(daemon=True)
+        self.hosts = hosts
+        self.port = port
+        self.result: list[hr.AddrInfo] | None = None
+        self.exception: Exception | None = None
+        self.event = threading.Event()
+
+    async def _resolve(self) -> None:
+        """Resolve hostnames to IP addresses."""
+        try:
+            self.result = await hr.async_resolve_host(
+                self.hosts, self.port, timeout=RESOLVE_TIMEOUT
+            )
+        except Exception as e:  # pylint: disable=broad-except
+            # We need to catch all exceptions to ensure the event is set
+            # Otherwise the thread could hang forever
+            self.exception = e
+        finally:
+            self.event.set()
+
+    def run(self) -> None:
+        """Run the DNS resolution."""
+        asyncio.run(self._resolve())
+
+    def resolve(self) -> list[hr.AddrInfo]:
+        """Start the thread and wait for the result."""
+        self.start()
+
+        if not self.event.wait(
+            timeout=RESOLVE_TIMEOUT + 1.0
+        ):  # Give it 1 second more than the resolver timeout
+            raise EsphomeError("Timeout resolving IP address")
+
+        if exc := self.exception:
+            if isinstance(exc, ResolveTimeoutAPIError):
+                raise EsphomeError(f"Timeout resolving IP address: {exc}") from exc
+            if isinstance(exc, ResolveAPIError):
+                raise EsphomeError(f"Error resolving IP address: {exc}") from exc
+            raise exc
+
+        return self.result

esphome/util.py

@@ -272,12 +272,15 @@ class OrderedDict(collections.OrderedDict):
         return dict(self).__repr__()
 
 
-def list_yaml_files(folders: list[str]) -> list[str]:
-    files = filter_yaml_files(
-        [os.path.join(folder, p) for folder in folders for p in os.listdir(folder)]
-    )
-    files.sort()
-    return files
+def list_yaml_files(configs: list[str]) -> list[str]:
+    files: list[str] = []
+    for config in configs:
+        if os.path.isfile(config):
+            files.append(config)
+        else:
+            files.extend(os.path.join(config, p) for p in os.listdir(config))
+    files = filter_yaml_files(files)
+    return sorted(files)
 
 
 def filter_yaml_files(files: list[str]) -> list[str]:

esphome/wizard.py

@@ -189,32 +189,45 @@ def wizard_write(path, **kwargs):
     from esphome.components.rtl87xx import boards as rtl87xx_boards
 
     name = kwargs["name"]
-    board = kwargs["board"]
-
-    for key in ("ssid", "psk", "password", "ota_password"):
-        if key in kwargs:
-            kwargs[key] = sanitize_double_quotes(kwargs[key])
-
-    if "platform" not in kwargs:
-        if board in esp8266_boards.BOARDS:
-            platform = "ESP8266"
-        elif board in esp32_boards.BOARDS:
-            platform = "ESP32"
-        elif board in rp2040_boards.BOARDS:
-            platform = "RP2040"
-        elif board in bk72xx_boards.BOARDS:
-            platform = "BK72XX"
-        elif board in ln882x_boards.BOARDS:
-            platform = "LN882X"
-        elif board in rtl87xx_boards.BOARDS:
-            platform = "RTL87XX"
-        else:
-            safe_print(color(AnsiFore.RED, f'The board "{board}" is unknown.'))
-            return False
-        kwargs["platform"] = platform
-    hardware = kwargs["platform"]
-
-    write_file(path, wizard_file(**kwargs))
+    if kwargs["type"] == "empty":
+        file_text = ""
+        # Will be updated later after editing the file
+        hardware = "UNKNOWN"
+    elif kwargs["type"] == "upload":
+        file_text = kwargs["file_text"]
+        hardware = "UNKNOWN"
+    else:  # "basic"
+        board = kwargs["board"]
+
+        for key in ("ssid", "psk", "password", "ota_password"):
+            if key in kwargs:
+                kwargs[key] = sanitize_double_quotes(kwargs[key])
+        if "platform" not in kwargs:
+            if board in esp8266_boards.BOARDS:
+                platform = "ESP8266"
+            elif board in esp32_boards.BOARDS:
+                platform = "ESP32"
+            elif board in rp2040_boards.BOARDS:
+                platform = "RP2040"
+            elif board in bk72xx_boards.BOARDS:
+                platform = "BK72XX"
+            elif board in ln882x_boards.BOARDS:
+                platform = "LN882X"
+            elif board in rtl87xx_boards.BOARDS:
+                platform = "RTL87XX"
+            else:
+                safe_print(color(AnsiFore.RED, f'The board "{board}" is unknown.'))
+                return False
+            kwargs["platform"] = platform
+        hardware = kwargs["platform"]
+        file_text = wizard_file(**kwargs)
+
+    # Check if file already exists to prevent overwriting
+    if os.path.exists(path) and os.path.isfile(path):
+        safe_print(color(AnsiFore.RED, f'The file "{path}" already exists.'))
+        return False
+
+    write_file(path, file_text)
     storage = StorageJSON.from_wizard(name, name, f"{name}.local", hardware)
     storage_path = ext_storage_path(os.path.basename(path))
     storage.save(storage_path)

{esphome-2025.8.3.dist-info → esphome-2025.9.0b1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: esphome
-Version: 2025.8.3
+Version: 2025.9.0b1
 Summary: ESPHome is a system to configure your microcontrollers by simple yet powerful configuration files and control them remotely through Home Automation systems.
 Author-email: The ESPHome Authors <esphome@openhomefoundation.org>
 License: MIT
@@ -36,11 +36,11 @@ Requires-Dist: pyserial==3.5
 Requires-Dist: platformio==6.1.18
 Requires-Dist: esptool==5.0.2
 Requires-Dist: click==8.1.7
-Requires-Dist: esphome-dashboard==20250814.0
-Requires-Dist: aioesphomeapi==39.0.0
-Requires-Dist: zeroconf==0.147.0
+Requires-Dist: esphome-dashboard==20250904.0
+Requires-Dist: aioesphomeapi==40.1.0
+Requires-Dist: zeroconf==0.147.2
 Requires-Dist: puremagic==1.30
-Requires-Dist: ruamel.yaml==0.18.14
+Requires-Dist: ruamel.yaml==0.18.15
 Requires-Dist: esphome-glyphsets==0.2.0
 Requires-Dist: pillow==10.4.0
 Requires-Dist: cairosvg==2.8.2
@@ -56,12 +56,12 @@ Requires-Dist: yamllint==1.37.1; extra == "dev"
 Provides-Extra: test
 Requires-Dist: pylint==3.3.8; extra == "test"
 Requires-Dist: flake8==7.3.0; extra == "test"
-Requires-Dist: ruff==0.12.8; extra == "test"
+Requires-Dist: ruff==0.12.12; extra == "test"
 Requires-Dist: pyupgrade==3.20.0; extra == "test"
 Requires-Dist: pre-commit; extra == "test"
-Requires-Dist: pytest==8.4.1; extra == "test"
-Requires-Dist: pytest-cov==6.2.1; extra == "test"
-Requires-Dist: pytest-mock==3.14.1; extra == "test"
+Requires-Dist: pytest==8.4.2; extra == "test"
+Requires-Dist: pytest-cov==7.0.0; extra == "test"
+Requires-Dist: pytest-mock==3.15.0; extra == "test"
 Requires-Dist: pytest-asyncio==1.1.0; extra == "test"
 Requires-Dist: pytest-xdist==3.8.0; extra == "test"
 Requires-Dist: asyncmock==0.4.2; extra == "test"