homeassistant 2025.8.3__py3-none-any.whl → 2025.9.0b0__py3-none-any.whl

homeassistant/const.py

@@ -24,8 +24,8 @@ if TYPE_CHECKING:
 
 APPLICATION_NAME: Final = "HomeAssistant"
 MAJOR_VERSION: Final = 2025
-MINOR_VERSION: Final = 8
-PATCH_VERSION: Final = "3"
+MINOR_VERSION: Final = 9
+PATCH_VERSION: Final = "0b0"
 __short_version__: Final = f"{MAJOR_VERSION}.{MINOR_VERSION}"
 __version__: Final = f"{__short_version__}.{PATCH_VERSION}"
 REQUIRED_PYTHON_VER: Final[tuple[int, int, int]] = (3, 13, 2)
@@ -469,6 +469,9 @@ ATTR_NAME: Final = "name"
 # Contains one string or a list of strings, each being an entity id
 ATTR_ENTITY_ID: Final = "entity_id"
 
+# Contains one string, the config entry ID
+ATTR_CONFIG_ENTRY_ID: Final = "config_entry_id"
+
 # Contains one string or a list of strings, each being an area id
 ATTR_AREA_ID: Final = "area_id"
 
@@ -585,6 +588,7 @@ ATTR_PERSONS: Final = "persons"
 class UnitOfApparentPower(StrEnum):
     """Apparent power units."""
 
+    MILLIVOLT_AMPERE = "mVA"
     VOLT_AMPERE = "VA"
 
 
@@ -605,6 +609,7 @@ class UnitOfPower(StrEnum):
 class UnitOfReactivePower(StrEnum):
     """Reactive power units."""
 
+    MILLIVOLT_AMPERE_REACTIVE = "mvar"
     VOLT_AMPERE_REACTIVE = "var"
     KILO_VOLT_AMPERE_REACTIVE = "kvar"
 
@@ -666,7 +671,7 @@ class UnitOfElectricCurrent(StrEnum):
 class UnitOfElectricPotential(StrEnum):
     """Electric potential units."""
 
-    MICROVOLT = "µV"
+    MICROVOLT = "μV"
     MILLIVOLT = "mV"
     VOLT = "V"
     KILOVOLT = "kV"
@@ -778,6 +783,7 @@ class UnitOfVolumeFlowRate(StrEnum):
     """Volume flow rate units."""
 
     CUBIC_METERS_PER_HOUR = "m³/h"
+    CUBIC_METERS_PER_MINUTE = "m³/min"
     CUBIC_METERS_PER_SECOND = "m³/s"
     CUBIC_FEET_PER_MINUTE = "ft³/min"
     LITERS_PER_HOUR = "L/h"
@@ -816,7 +822,7 @@ class UnitOfMass(StrEnum):
     GRAMS = "g"
     KILOGRAMS = "kg"
     MILLIGRAMS = "mg"
-    MICROGRAMS = "µg"
+    MICROGRAMS = "μg"
     OUNCES = "oz"
     POUNDS = "lb"
     STONES = "st"
@@ -834,13 +840,13 @@ class UnitOfConductivity(
     """Conductivity units."""
 
     SIEMENS_PER_CM = "S/cm"
-    MICROSIEMENS_PER_CM = "µS/cm"
+    MICROSIEMENS_PER_CM = "μS/cm"
     MILLISIEMENS_PER_CM = "mS/cm"
 
     # Deprecated aliases
     SIEMENS = "S/cm"
     """Deprecated: Please use UnitOfConductivity.SIEMENS_PER_CM"""
-    MICROSIEMENS = "µS/cm"
+    MICROSIEMENS = "μS/cm"
     """Deprecated: Please use UnitOfConductivity.MICROSIEMENS_PER_CM"""
     MILLISIEMENS = "mS/cm"
     """Deprecated: Please use UnitOfConductivity.MILLISIEMENS_PER_CM"""
@@ -912,8 +918,8 @@ class UnitOfPrecipitationDepth(StrEnum):
 
 # Concentration units
 CONCENTRATION_GRAMS_PER_CUBIC_METER: Final = "g/m³"
-CONCENTRATION_MICROGRAMS_PER_CUBIC_METER: Final = "µg/m³"
 CONCENTRATION_MILLIGRAMS_PER_CUBIC_METER: Final = "mg/m³"
+CONCENTRATION_MICROGRAMS_PER_CUBIC_METER: Final = "μg/m³"
 CONCENTRATION_MICROGRAMS_PER_CUBIC_FOOT: Final = "μg/ft³"
 CONCENTRATION_PARTS_PER_CUBIC_METER: Final = "p/m³"
 CONCENTRATION_PARTS_PER_MILLION: Final = "ppm"

homeassistant/data_entry_flow.py

@@ -142,7 +142,6 @@ class FlowResult(TypedDict, Generic[_FlowContextT, _HandlerT], total=False):
     progress_task: asyncio.Task[Any] | None
     reason: str
     required: bool
-    result: Any
     step_id: str
     title: str
     translation_domain: str
@@ -707,10 +706,7 @@ class FlowHandler(Generic[_FlowContextT, _FlowResultT, _HandlerT]):
         last_step: bool | None = None,
         preview: str | None = None,
     ) -> _FlowResultT:
-        """Return the definition of a form to gather user input.
-
-        The step_id parameter is deprecated and will be removed in a future release.
-        """
+        """Return the definition of a form to gather user input."""
         flow_result = self._flow_result(
             type=FlowResultType.FORM,
             flow_id=self.flow_id,
@@ -772,10 +768,7 @@ class FlowHandler(Generic[_FlowContextT, _FlowResultT, _HandlerT]):
         url: str,
         description_placeholders: Mapping[str, str] | None = None,
     ) -> _FlowResultT:
-        """Return the definition of an external step for the user to take.
-
-        The step_id parameter is deprecated and will be removed in a future release.
-        """
+        """Return the definition of an external step for the user to take."""
         flow_result = self._flow_result(
             type=FlowResultType.EXTERNAL_STEP,
             flow_id=self.flow_id,
@@ -806,10 +799,7 @@ class FlowHandler(Generic[_FlowContextT, _FlowResultT, _HandlerT]):
         description_placeholders: Mapping[str, str] | None = None,
         progress_task: asyncio.Task[Any] | None = None,
     ) -> _FlowResultT:
-        """Show a progress message to the user, without user input allowed.
-
-        The step_id parameter is deprecated and will be removed in a future release.
-        """
+        """Show a progress message to the user, without user input allowed."""
         if progress_task is None and not self.__no_progress_task_reported:
             self.__no_progress_task_reported = True
             cls = self.__class__
@@ -869,7 +859,6 @@ class FlowHandler(Generic[_FlowContextT, _FlowResultT, _HandlerT]):
         """Show a navigation menu to the user.
 
         Options dict maps step_id => i18n label
-        The step_id parameter is deprecated and will be removed in a future release.
         """
         flow_result = self._flow_result(
             type=FlowResultType.MENU,

homeassistant/generated/application_credentials.py

@@ -4,6 +4,8 @@ To update, run python3 -m script.hassfest
 """
 
 APPLICATION_CREDENTIALS = [
+    "aladdin_connect",
+    "august",
     "electric_kiwi",
     "fitbit",
     "geocaching",

homeassistant/generated/bluetooth.py

@@ -386,6 +386,11 @@ BLUETOOTH: Final[list[dict[str, bool | str | int | list[int]]]] = [
         "domain": "inkbird",
         "local_name": "Ink@IAM-T1",
     },
+    {
+        "connectable": True,
+        "domain": "inkbird",
+        "local_name": "Ink@IAM-T2",
+    },
     {
         "connectable": True,
         "domain": "inkbird",
@@ -396,6 +401,16 @@ BLUETOOTH: Final[list[dict[str, bool | str | int | list[int]]]] = [
         ],
         "manufacturer_id": 12628,
     },
+    {
+        "connectable": False,
+        "domain": "inkbird",
+        "manufacturer_data_start": [
+            0,
+            98,
+            0,
+        ],
+        "manufacturer_id": 12884,
+    },
     {
         "connectable": True,
         "domain": "iron_os",
@@ -819,6 +834,12 @@ BLUETOOTH: Final[list[dict[str, bool | str | int | list[int]]]] = [
         ],
         "manufacturer_id": 76,
     },
+    {
+        "connectable": True,
+        "domain": "togrill",
+        "manufacturer_id": 34714,
+        "service_uuid": "0000cee0-0000-1000-8000-00805f9b34fb",
+    },
     {
         "connectable": False,
         "domain": "xiaomi_ble",

homeassistant/generated/config_flows.py

@@ -47,6 +47,7 @@ FLOWS = {
         "airvisual_pro",
         "airzone",
         "airzone_cloud",
+        "aladdin_connect",
         "alarmdecoder",
         "alexa_devices",
         "altruist",
@@ -87,6 +88,7 @@ FLOWS = {
         "baf",
         "balboa",
         "bang_olufsen",
+        "bayesian",
         "blebox",
         "blink",
         "blue_current",
@@ -348,7 +350,6 @@ FLOWS = {
         "lg_thinq",
         "lidarr",
         "lifx",
-        "linear_garage_door",
         "linkplay",
         "litejet",
         "litterrobot",
@@ -489,6 +490,7 @@ FLOWS = {
         "plugwise",
         "plum_lightpad",
         "point",
+        "pooldose",
         "poolsense",
         "powerfox",
         "powerwall",
@@ -577,6 +579,7 @@ FLOWS = {
         "sky_remote",
         "skybell",
         "slack",
+        "sleep_as_android",
         "sleepiq",
         "slide_local",
         "slimproto",
@@ -654,6 +657,7 @@ FLOWS = {
         "tilt_pi",
         "time_date",
         "todoist",
+        "togrill",
         "tolo",
         "tomorrowio",
         "toon",

homeassistant/generated/integrations.json

@@ -437,11 +437,6 @@
       "config_flow": false,
       "iot_class": "cloud_push"
     },
-    "aps": {
-      "name": "Arizona Public Service (APS)",
-      "integration_type": "virtual",
-      "supported_by": "opower"
-    },
     "apsystems": {
       "name": "APsystems",
       "integration_type": "device",
@@ -670,6 +665,12 @@
       "integration_type": "virtual",
       "supported_by": "whirlpool"
     },
+    "bayesian": {
+      "name": "Bayesian",
+      "integration_type": "service",
+      "config_flow": true,
+      "iot_class": "calculated"
+    },
     "bbox": {
       "name": "Bbox",
       "integration_type": "hub",
@@ -3512,12 +3513,6 @@
       "integration_type": "virtual",
       "supported_by": "idasen_desk"
     },
-    "linear_garage_door": {
-      "name": "Linear Garage Door",
-      "integration_type": "hub",
-      "config_flow": true,
-      "iot_class": "cloud_polling"
-    },
     "linkedgo": {
       "name": "LinkedGo",
       "integration_type": "virtual",
@@ -3839,11 +3834,6 @@
       "config_flow": false,
       "iot_class": "cloud_polling"
     },
-    "mercury_nz": {
-      "name": "Mercury NZ Limited",
-      "integration_type": "virtual",
-      "supported_by": "opower"
-    },
     "message_bird": {
       "name": "MessageBird",
       "integration_type": "hub",
@@ -5047,6 +5037,12 @@
       "config_flow": true,
       "iot_class": "cloud_polling"
     },
+    "pooldose": {
+      "name": "SEKO PoolDose",
+      "integration_type": "hub",
+      "config_flow": true,
+      "iot_class": "local_polling"
+    },
     "poolsense": {
       "name": "PoolSense",
       "integration_type": "hub",
@@ -6005,6 +6001,12 @@
       "config_flow": true,
       "iot_class": "cloud_push"
     },
+    "sleep_as_android": {
+      "name": "Sleep as Android",
+      "integration_type": "hub",
+      "config_flow": true,
+      "iot_class": "local_push"
+    },
     "sleepiq": {
       "name": "SleepIQ",
       "integration_type": "hub",
@@ -6796,6 +6798,12 @@
       "config_flow": true,
       "iot_class": "cloud_polling"
     },
+    "togrill": {
+      "name": "ToGrill",
+      "integration_type": "hub",
+      "config_flow": true,
+      "iot_class": "local_push"
+    },
     "tolo": {
       "name": "TOLO Sauna",
       "integration_type": "hub",
@@ -7768,12 +7776,6 @@
     }
   },
   "helper": {
-    "bayesian": {
-      "name": "Bayesian",
-      "integration_type": "helper",
-      "config_flow": false,
-      "iot_class": "local_polling"
-    },
     "counter": {
       "integration_type": "helper",
       "config_flow": false

homeassistant/generated/usb.py

@@ -143,6 +143,12 @@ USB = [
         "pid": "EA60",
         "vid": "10C4",
     },
+    {
+        "description": "*sonoff*lite*mg21*",
+        "domain": "zha",
+        "pid": "EA60",
+        "vid": "10C4",
+    },
     {
         "domain": "zwave_js",
         "pid": "0200",

homeassistant/generated/zeroconf.py

@@ -890,6 +890,10 @@ ZEROCONF = {
         },
     ],
     "_ssh._tcp.local.": [
+        {
+            "domain": "homee",
+            "name": "homee-*",
+        },
         {
             "domain": "smappee",
             "name": "smappee1*",

homeassistant/helpers/automation.py

@@ -0,0 +1,21 @@
+"""Helpers for automation."""
+
+
+def get_absolute_description_key(domain: str, key: str) -> str:
+    """Return the absolute description key."""
+    if not key.startswith("_"):
+        return f"{domain}.{key}"
+    key = key[1:]  # Remove leading underscore
+    if not key:
+        return domain
+    return key
+
+
+def get_relative_description_key(domain: str, key: str) -> str:
+    """Return the relative description key."""
+    platform, *subtype = key.split(".", 1)
+    if platform != domain:
+        return f"_{key}"
+    if not subtype:
+        return "_"
+    return subtype[0]

homeassistant/helpers/condition.py

@@ -58,9 +58,9 @@ from homeassistant.util import dt as dt_util
 from homeassistant.util.async_ import run_callback_threadsafe
 from homeassistant.util.hass_dict import HassKey
 from homeassistant.util.yaml import load_yaml_dict
-from homeassistant.util.yaml.loader import JSON_TYPE
 
 from . import config_validation as cv, entity_registry as er
+from .automation import get_absolute_description_key, get_relative_description_key
 from .integration_platform import async_process_integration_platforms
 from .template import Template, render_complex
 from .trace import (
@@ -132,7 +132,7 @@ def starts_with_dot(key: str) -> str:
 _CONDITIONS_SCHEMA = vol.Schema(
     {
         vol.Remove(vol.All(str, starts_with_dot)): object,
-        cv.slug: vol.Any(None, _CONDITION_SCHEMA),
+        cv.underscore_slug: vol.Any(None, _CONDITION_SCHEMA),
     }
 )
 
@@ -171,6 +171,9 @@ async def _register_condition_platform(
 
     if hasattr(platform, "async_get_conditions"):
         for condition_key in await platform.async_get_conditions(hass):
+            condition_key = get_absolute_description_key(
+                integration_domain, condition_key
+            )
             hass.data[CONDITIONS][condition_key] = integration_domain
             new_conditions.add(condition_key)
     else:
@@ -199,14 +202,14 @@ class Condition(abc.ABC):
 
     @classmethod
     @abc.abstractmethod
-    async def async_validate_condition_config(
+    async def async_validate_config(
         cls, hass: HomeAssistant, config: ConfigType
     ) -> ConfigType:
         """Validate config."""
 
     @abc.abstractmethod
-    async def async_condition_from_config(self) -> ConditionCheckerType:
-        """Evaluate state based on configuration."""
+    async def async_get_checker(self) -> ConditionCheckerType:
+        """Get the condition checker."""
 
 
 class ConditionProtocol(Protocol):
@@ -288,22 +291,21 @@ def trace_condition_function(condition: ConditionCheckerType) -> ConditionChecke
 
 
 async def _async_get_condition_platform(
-    hass: HomeAssistant, config: ConfigType
-) -> ConditionProtocol | None:
-    condition_key: str = config[CONF_CONDITION]
-    platform_and_sub_type = condition_key.partition(".")
+    hass: HomeAssistant, condition_key: str
+) -> tuple[str, ConditionProtocol | None]:
+    platform_and_sub_type = condition_key.split(".")
     platform: str | None = platform_and_sub_type[0]
     platform = _PLATFORM_ALIASES.get(platform, platform)
     if platform is None:
-        return None
+        return "", None
     try:
         integration = await async_get_integration(hass, platform)
     except IntegrationNotFound:
         raise HomeAssistantError(
-            f'Invalid condition "{condition_key}" specified {config}'
+            f'Invalid condition "{condition_key}" specified'
         ) from None
     try:
-        return await integration.async_get_platform("condition")
+        return platform, await integration.async_get_platform("condition")
     except ImportError:
         raise HomeAssistantError(
             f"Integration '{platform}' does not provide condition support"
@@ -339,17 +341,20 @@ async def async_from_config(
 
             return disabled_condition
 
-    condition: str = config[CONF_CONDITION]
+    condition_key: str = config[CONF_CONDITION]
     factory: Any = None
-    platform = await _async_get_condition_platform(hass, config)
+    platform_domain, platform = await _async_get_condition_platform(hass, condition_key)
 
     if platform is not None:
         condition_descriptors = await platform.async_get_conditions(hass)
-        condition_instance = condition_descriptors[condition](hass, config)
-        return await condition_instance.async_condition_from_config()
+        relative_condition_key = get_relative_description_key(
+            platform_domain, condition_key
+        )
+        condition_instance = condition_descriptors[relative_condition_key](hass, config)
+        return await condition_instance.async_get_checker()
 
     for fmt in (ASYNC_FROM_CONFIG_FORMAT, FROM_CONFIG_FORMAT):
-        factory = getattr(sys.modules[__name__], fmt.format(condition), None)
+        factory = getattr(sys.modules[__name__], fmt.format(condition_key), None)
 
         if factory:
             break
@@ -960,8 +965,9 @@ async def async_validate_condition_config(
     hass: HomeAssistant, config: ConfigType
 ) -> ConfigType:
     """Validate config."""
-    condition: str = config[CONF_CONDITION]
-    if condition in ("and", "not", "or"):
+    condition_key: str = config[CONF_CONDITION]
+
+    if condition_key in ("and", "not", "or"):
         conditions = []
         for sub_cond in config["conditions"]:
             sub_cond = await async_validate_condition_config(hass, sub_cond)
@@ -969,16 +975,23 @@ async def async_validate_condition_config(
         config["conditions"] = conditions
         return config
 
-    platform = await _async_get_condition_platform(hass, config)
+    platform_domain, platform = await _async_get_condition_platform(hass, condition_key)
+
     if platform is not None:
         condition_descriptors = await platform.async_get_conditions(hass)
-        if not (condition_class := condition_descriptors.get(condition)):
-            raise vol.Invalid(f"Invalid condition '{condition}' specified")
-        return await condition_class.async_validate_condition_config(hass, config)
-    if platform is None and condition in ("numeric_state", "state"):
+        relative_condition_key = get_relative_description_key(
+            platform_domain, condition_key
+        )
+        if not (condition_class := condition_descriptors.get(relative_condition_key)):
+            raise vol.Invalid(f"Invalid condition '{condition_key}' specified")
+        return await condition_class.async_validate_config(hass, config)
+
+    if platform is None and condition_key in ("numeric_state", "state"):
         validator = cast(
             Callable[[HomeAssistant, ConfigType], ConfigType],
-            getattr(sys.modules[__name__], VALIDATE_CONFIG_FORMAT.format(condition)),
+            getattr(
+                sys.modules[__name__], VALIDATE_CONFIG_FORMAT.format(condition_key)
+            ),
         )
         return validator(hass, config)
 
@@ -1088,11 +1101,11 @@ def async_extract_devices(config: ConfigType | Template) -> set[str]:
     return referenced
 
 
-def _load_conditions_file(hass: HomeAssistant, integration: Integration) -> JSON_TYPE:
+def _load_conditions_file(integration: Integration) -> dict[str, Any]:
     """Load conditions file for an integration."""
     try:
         return cast(
-            JSON_TYPE,
+            dict[str, Any],
             _CONDITIONS_SCHEMA(
                 load_yaml_dict(str(integration.file_path / "conditions.yaml"))
             ),
@@ -1112,11 +1125,14 @@ def _load_conditions_file(hass: HomeAssistant, integration: Integration) -> JSON
 
 
 def _load_conditions_files(
-    hass: HomeAssistant, integrations: Iterable[Integration]
-) -> dict[str, JSON_TYPE]:
+    integrations: Iterable[Integration],
+) -> dict[str, dict[str, Any]]:
     """Load condition files for multiple integrations."""
     return {
-        integration.domain: _load_conditions_file(hass, integration)
+        integration.domain: {
+            get_absolute_description_key(integration.domain, key): value
+            for key, value in _load_conditions_file(integration).items()
+        }
         for integration in integrations
     }
 
@@ -1137,7 +1153,7 @@ async def async_get_all_descriptions(
         return descriptions_cache
 
     # Files we loaded for missing descriptions
-    new_conditions_descriptions: dict[str, JSON_TYPE] = {}
+    new_conditions_descriptions: dict[str, dict[str, Any]] = {}
     # We try to avoid making a copy in the event the cache is good,
     # but now we must make a copy in case new conditions get added
     # while we are loading the missing ones so we do not
@@ -1166,7 +1182,7 @@ async def async_get_all_descriptions(
 
         if integrations:
             new_conditions_descriptions = await hass.async_add_executor_job(
-                _load_conditions_files, hass, integrations
+                _load_conditions_files, integrations
             )
 
     # Make a copy of the old cache and add missing descriptions to it
@@ -1175,7 +1191,7 @@ async def async_get_all_descriptions(
         domain = conditions[missing_condition]
 
         if (
-            yaml_description := new_conditions_descriptions.get(domain, {}).get(  # type: ignore[union-attr]
+            yaml_description := new_conditions_descriptions.get(domain, {}).get(
                 missing_condition
             )
         ) is None:

homeassistant/helpers/config_entry_oauth2_flow.py

@@ -155,7 +155,7 @@ class LocalOAuth2Implementation(AbstractOAuth2Implementation):
     @property
     def name(self) -> str:
         """Name of the implementation."""
-        return "Configuration.yaml"
+        return "Local application credentials"
 
     @property
     def domain(self) -> str:

homeassistant/helpers/config_validation.py

@@ -373,6 +373,17 @@ def entity_id(value: Any) -> str:
     raise vol.Invalid(f"Entity ID {value} is an invalid entity ID")
 
 
+def strict_entity_id(value: Any) -> str:
+    """Validate Entity ID, strictly."""
+    if not isinstance(value, str):
+        raise vol.Invalid(f"Entity ID {value} is not a string")
+
+    if valid_entity_id(value):
+        return value
+
+    raise vol.Invalid(f"Entity ID {value} is not a valid entity ID")
+
+
 def entity_id_or_uuid(value: Any) -> str:
     """Validate Entity specified by entity_id or uuid."""
     with contextlib.suppress(vol.Invalid):
@@ -644,6 +655,13 @@ def slug(value: Any) -> str:
     raise vol.Invalid(f"invalid slug {value} (try {slg})")
 
 
+def underscore_slug(value: Any) -> str:
+    """Validate value is a valid slug, possibly starting with an underscore."""
+    if value.startswith("_"):
+        return f"_{slug(value[1:])}"
+    return slug(value)
+
+
 def schema_with_slug_keys(
     value_schema: dict | Callable, *, slug_validator: Callable[[Any], str] = slug
 ) -> Callable:
@@ -1285,6 +1303,15 @@ PLATFORM_SCHEMA = vol.Schema(
 
 PLATFORM_SCHEMA_BASE = PLATFORM_SCHEMA.extend({}, extra=vol.ALLOW_EXTRA)
 
+
+TARGET_FIELDS: VolDictType = {
+    vol.Optional(ATTR_ENTITY_ID): vol.All(ensure_list, [strict_entity_id]),
+    vol.Optional(ATTR_DEVICE_ID): vol.All(ensure_list, [str]),
+    vol.Optional(ATTR_AREA_ID): vol.All(ensure_list, [str]),
+    vol.Optional(ATTR_FLOOR_ID): vol.All(ensure_list, [str]),
+    vol.Optional(ATTR_LABEL_ID): vol.All(ensure_list, [str]),
+}
+
 ENTITY_SERVICE_FIELDS: VolDictType = {
     # Either accept static entity IDs, a single dynamic template or a mixed list
     # of static and dynamic templates. While this could be solved with a single