Extra line breaks to make the if/elif more distinct

* Commit split issue

* Clearer name

* Add yaml_failure test case

* Not sure why this is failing now

* Update homeassistant/components/obihai/strings.json

Co-authored-by: epenet <6771947+epenet@users.noreply.github.com>

* PR Feedback

* Update homeassistant/components/obihai/config_flow.py

Co-authored-by: epenet <6771947+epenet@users.noreply.github.com>

---------

Co-authored-by: epenet <6771947+epenet@users.noreply.github.com>

.coveragerc

@@ -807,6 +807,7 @@ omit =
     homeassistant/components/nuki/sensor.py
     homeassistant/components/nx584/alarm_control_panel.py
     homeassistant/components/oasa_telematics/sensor.py
+    homeassistant/components/obihai/__init__.py
     homeassistant/components/obihai/connectivity.py
     homeassistant/components/obihai/sensor.py
     homeassistant/components/octoprint/__init__.py
@@ -1368,7 +1369,6 @@ omit =
     homeassistant/components/verisure/sensor.py
     homeassistant/components/verisure/switch.py
     homeassistant/components/versasense/*
-    homeassistant/components/vesync/__init__.py
     homeassistant/components/vesync/common.py
     homeassistant/components/vesync/fan.py
     homeassistant/components/vesync/light.py

CODEOWNERS

@@ -659,8 +659,8 @@ build.json @home-assistant/supervisor
 /tests/components/litejet/ @joncar
 /homeassistant/components/litterrobot/ @natekspencer @tkdrob
 /tests/components/litterrobot/ @natekspencer @tkdrob
-/homeassistant/components/livisi/ @StefanIacobLivisi
-/tests/components/livisi/ @StefanIacobLivisi
+/homeassistant/components/livisi/ @StefanIacobLivisi @planbnet
+/tests/components/livisi/ @StefanIacobLivisi @planbnet
 /homeassistant/components/local_calendar/ @allenporter
 /tests/components/local_calendar/ @allenporter
 /homeassistant/components/local_ip/ @issacg
@@ -1213,8 +1213,6 @@ build.json @home-assistant/supervisor
 /homeassistant/components/thethingsnetwork/ @fabaff
 /homeassistant/components/thread/ @home-assistant/core
 /tests/components/thread/ @home-assistant/core
-/homeassistant/components/threshold/ @fabaff
-/tests/components/threshold/ @fabaff
 /homeassistant/components/tibber/ @danielhiversen
 /tests/components/tibber/ @danielhiversen
 /homeassistant/components/tile/ @bachya

homeassistant/auth/permissions/models.py

@@ -6,15 +6,12 @@ from typing import TYPE_CHECKING
 import attr
 
 if TYPE_CHECKING:
-    from homeassistant.helpers import (
-        device_registry as dev_reg,
-        entity_registry as ent_reg,
-    )
+    from homeassistant.helpers import device_registry as dr, entity_registry as er
 
 
 @attr.s(slots=True)
 class PermissionLookup:
     """Class to hold data for permission lookups."""
 
-    entity_registry: ent_reg.EntityRegistry = attr.ib()
-    device_registry: dev_reg.DeviceRegistry = attr.ib()
+    entity_registry: er.EntityRegistry = attr.ib()
+    device_registry: dr.DeviceRegistry = attr.ib()

homeassistant/brands/heltun.json

@@ -0,0 +1,5 @@
+{
+  "domain": "heltun",
+  "name": "HELTUN",
+  "iot_standards": ["zwave"]
+}

homeassistant/components/alarm_control_panel/device_action.py

@@ -21,7 +21,7 @@ from homeassistant.const import (
     SERVICE_ALARM_TRIGGER,
 )
 from homeassistant.core import Context, HomeAssistant
-from homeassistant.helpers import entity_registry
+from homeassistant.helpers import entity_registry as er
 import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.entity import get_supported_features
 from homeassistant.helpers.typing import ConfigType, TemplateVarsType
@@ -57,11 +57,11 @@ async def async_get_actions(
     hass: HomeAssistant, device_id: str
 ) -> list[dict[str, str]]:
     """List device actions for Alarm control panel devices."""
-    registry = entity_registry.async_get(hass)
+    registry = er.async_get(hass)
     actions = []
 
     # Get all the integrations entities for this device
-    for entry in entity_registry.async_entries_for_device(registry, device_id):
+    for entry in er.async_entries_for_device(registry, device_id):
         if entry.domain != DOMAIN:
             continue
 

homeassistant/components/alarm_control_panel/device_condition.py

@@ -21,7 +21,11 @@ from homeassistant.const import (
     STATE_ALARM_TRIGGERED,
 )
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers import condition, config_validation as cv, entity_registry
+from homeassistant.helpers import (
+    condition,
+    config_validation as cv,
+    entity_registry as er,
+)
 from homeassistant.helpers.config_validation import DEVICE_CONDITION_BASE_SCHEMA
 from homeassistant.helpers.entity import get_supported_features
 from homeassistant.helpers.typing import ConfigType, TemplateVarsType
@@ -64,11 +68,11 @@ async def async_get_conditions(
     hass: HomeAssistant, device_id: str
 ) -> list[dict[str, str]]:
     """List device conditions for Alarm control panel devices."""
-    registry = entity_registry.async_get(hass)
+    registry = er.async_get(hass)
     conditions = []
 
     # Get all the integrations entities for this device
-    for entry in entity_registry.async_entries_for_device(registry, device_id):
+    for entry in er.async_entries_for_device(registry, device_id):
         if entry.domain != DOMAIN:
             continue
 

homeassistant/components/alarm_control_panel/device_trigger.py

@@ -23,7 +23,7 @@ from homeassistant.const import (
     STATE_ALARM_TRIGGERED,
 )
 from homeassistant.core import CALLBACK_TYPE, HomeAssistant
-from homeassistant.helpers import config_validation as cv, entity_registry
+from homeassistant.helpers import config_validation as cv, entity_registry as er
 from homeassistant.helpers.entity import get_supported_features
 from homeassistant.helpers.trigger import TriggerActionType, TriggerInfo
 from homeassistant.helpers.typing import ConfigType
@@ -57,11 +57,11 @@ async def async_get_triggers(
     hass: HomeAssistant, device_id: str
 ) -> list[dict[str, str]]:
     """List device triggers for Alarm control panel devices."""
-    registry = entity_registry.async_get(hass)
+    registry = er.async_get(hass)
     triggers: list[dict[str, str]] = []
 
     # Get all the integrations entities for this device
-    for entry in entity_registry.async_entries_for_device(registry, device_id):
+    for entry in er.async_entries_for_device(registry, device_id):
         if entry.domain != DOMAIN:
             continue
 

homeassistant/components/amcrest/camera.py

@@ -20,13 +20,12 @@ from homeassistant.components.camera import (
 from homeassistant.components.ffmpeg import FFmpegManager, get_ffmpeg_manager
 from homeassistant.const import ATTR_ENTITY_ID, CONF_NAME, STATE_OFF, STATE_ON
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers import entity_registry
+from homeassistant.helpers import config_validation as cv, entity_registry as er
 from homeassistant.helpers.aiohttp_client import (
     async_aiohttp_proxy_stream,
     async_aiohttp_proxy_web,
     async_get_clientsession,
 )
-import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
@@ -146,7 +145,7 @@ async def async_setup_platform(
     # with this version, update the old entity with the new unique id.
     serial_number = await device.api.async_serial_number
     serial_number = serial_number.strip()
-    registry = entity_registry.async_get(hass)
+    registry = er.async_get(hass)
     entity_id = registry.async_get_entity_id(CAMERA_DOMAIN, DOMAIN, serial_number)
     if entity_id is not None:
         _LOGGER.debug("Updating unique id for camera %s", entity_id)

homeassistant/components/arcam_fmj/device_trigger.py

@@ -13,7 +13,7 @@ from homeassistant.const import (
     CONF_TYPE,
 )
 from homeassistant.core import CALLBACK_TYPE, Event, HassJob, HomeAssistant, callback
-from homeassistant.helpers import config_validation as cv, entity_registry
+from homeassistant.helpers import config_validation as cv, entity_registry as er
 from homeassistant.helpers.trigger import TriggerActionType, TriggerInfo
 from homeassistant.helpers.typing import ConfigType
 
@@ -32,11 +32,11 @@ async def async_get_triggers(
     hass: HomeAssistant, device_id: str
 ) -> list[dict[str, str]]:
     """List device triggers for Arcam FMJ Receiver control devices."""
-    registry = entity_registry.async_get(hass)
+    registry = er.async_get(hass)
     triggers = []
 
     # Get all the integrations entities for this device
-    for entry in entity_registry.async_entries_for_device(registry, device_id):
+    for entry in er.async_entries_for_device(registry, device_id):
         if entry.domain == "media_player":
             triggers.append(
                 {

homeassistant/components/arwn/sensor.py

@@ -1,7 +1,6 @@
 """Support for collecting data from the ARWN project."""
 from __future__ import annotations
 
-import json
 import logging
 
 from homeassistant.components import mqtt
@@ -11,6 +10,7 @@ from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 from homeassistant.util import slugify
+from homeassistant.util.json import json_loads_object
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -102,7 +102,7 @@ async def async_setup_platform(
     """Set up the ARWN platform."""
 
     @callback
-    def async_sensor_event_received(msg):
+    def async_sensor_event_received(msg: mqtt.ReceiveMessage) -> None:
         """Process events as sensors.
 
         When a new event on our topic (arwn/#) is received we map it
@@ -115,7 +115,7 @@ async def async_setup_platform(
         This lets us dynamically incorporate sensors without any
         configuration on our side.
         """
-        event = json.loads(msg.payload)
+        event = json_loads_object(msg.payload)
         sensors = discover_sensors(msg.topic, event)
         if not sensors:
             return

homeassistant/components/aurora/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/aurora",
   "iot_class": "cloud_polling",
   "loggers": ["auroranoaa"],
-  "requirements": ["auroranoaa==0.0.2"]
+  "requirements": ["auroranoaa==0.0.3"]
 }

homeassistant/components/aurora/sensor.py

@@ -1,5 +1,5 @@
 """Support for Aurora Forecast sensor."""
-from homeassistant.components.sensor import SensorEntity
+from homeassistant.components.sensor import SensorEntity, SensorStateClass
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import PERCENTAGE
 from homeassistant.core import HomeAssistant
@@ -28,6 +28,7 @@ class AuroraSensor(AuroraEntity, SensorEntity):
     """Implementation of an aurora sensor."""
 
     _attr_native_unit_of_measurement = PERCENTAGE
+    _attr_state_class = SensorStateClass.MEASUREMENT
 
     @property
     def native_value(self):

homeassistant/components/bayesian/repairs.py

@@ -2,7 +2,7 @@
 from __future__ import annotations
 
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers import issue_registry
+from homeassistant.helpers import issue_registry as ir
 
 from . import DOMAIN
 from .helpers import Observation
@@ -15,13 +15,13 @@ def raise_mirrored_entries(
     if len(observations) != 2:
         return
     if observations[0].is_mirror(observations[1]):
-        issue_registry.async_create_issue(
+        ir.async_create_issue(
             hass,
             DOMAIN,
             "mirrored_entry/" + text,
             breaks_in_ha_version="2022.10.0",
             is_fixable=False,
-            severity=issue_registry.IssueSeverity.WARNING,
+            severity=ir.IssueSeverity.WARNING,
             translation_key="manual_migration",
             translation_placeholders={"entity": text},
             learn_more_url="https://github.com/home-assistant/core/pull/67631",
@@ -31,13 +31,13 @@ def raise_mirrored_entries(
 # Should deprecate in some future version (2022.10 at time of writing) & make prob_given_false required in schemas.
 def raise_no_prob_given_false(hass: HomeAssistant, text: str) -> None:
     """In previous 2022.9 and earlier, prob_given_false was optional and had a default version."""
-    issue_registry.async_create_issue(
+    ir.async_create_issue(
         hass,
         DOMAIN,
         f"no_prob_given_false/{text}",
         breaks_in_ha_version="2022.10.0",
         is_fixable=False,
-        severity=issue_registry.IssueSeverity.ERROR,
+        severity=ir.IssueSeverity.ERROR,
         translation_key="no_prob_given_false",
         translation_placeholders={"entity": text},
         learn_more_url="https://github.com/home-assistant/core/pull/67631",

homeassistant/components/button/device_action.py

@@ -11,7 +11,7 @@ from homeassistant.const import (
     CONF_TYPE,
 )
 from homeassistant.core import Context, HomeAssistant
-from homeassistant.helpers import entity_registry
+from homeassistant.helpers import entity_registry as er
 import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.typing import ConfigType, TemplateVarsType
 
@@ -31,7 +31,7 @@ async def async_get_actions(
     hass: HomeAssistant, device_id: str
 ) -> list[dict[str, str]]:
     """List device actions for button devices."""
-    registry = entity_registry.async_get(hass)
+    registry = er.async_get(hass)
     return [
         {
             CONF_DEVICE_ID: device_id,
@@ -39,7 +39,7 @@ async def async_get_actions(
             CONF_ENTITY_ID: entry.entity_id,
             CONF_TYPE: "press",
         }
-        for entry in entity_registry.async_entries_for_device(registry, device_id)
+        for entry in er.async_entries_for_device(registry, device_id)
         if entry.domain == DOMAIN
     ]
 

homeassistant/components/button/device_trigger.py

@@ -16,7 +16,7 @@ from homeassistant.const import (
     CONF_TYPE,
 )
 from homeassistant.core import CALLBACK_TYPE, HomeAssistant
-from homeassistant.helpers import config_validation as cv, entity_registry
+from homeassistant.helpers import config_validation as cv, entity_registry as er
 from homeassistant.helpers.trigger import TriggerActionType, TriggerInfo
 from homeassistant.helpers.typing import ConfigType
 
@@ -36,7 +36,7 @@ async def async_get_triggers(
     hass: HomeAssistant, device_id: str
 ) -> list[dict[str, str]]:
     """List device triggers for button devices."""
-    registry = entity_registry.async_get(hass)
+    registry = er.async_get(hass)
     return [
         {
             CONF_PLATFORM: "device",
@@ -45,7 +45,7 @@ async def async_get_triggers(
             CONF_ENTITY_ID: entry.entity_id,
             CONF_TYPE: "pressed",
         }
-        for entry in entity_registry.async_entries_for_device(registry, device_id)
+        for entry in er.async_entries_for_device(registry, device_id)
         if entry.domain == DOMAIN
     ]
 

homeassistant/components/climate/device_action.py

@@ -12,7 +12,7 @@ from homeassistant.const import (
 )
 from homeassistant.core import Context, HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers import entity_registry
+from homeassistant.helpers import entity_registry as er
 import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.entity import get_capability, get_supported_features
 from homeassistant.helpers.typing import ConfigType, TemplateVarsType
@@ -44,11 +44,11 @@ async def async_get_actions(
     hass: HomeAssistant, device_id: str
 ) -> list[dict[str, str]]:
     """List device actions for Climate devices."""
-    registry = entity_registry.async_get(hass)
+    registry = er.async_get(hass)
     actions = []
 
     # Get all the integrations entities for this device
-    for entry in entity_registry.async_entries_for_device(registry, device_id):
+    for entry in er.async_entries_for_device(registry, device_id):
         if entry.domain != DOMAIN:
             continue
 

homeassistant/components/climate/device_condition.py

@@ -13,7 +13,11 @@ from homeassistant.const import (
 )
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers import condition, config_validation as cv, entity_registry
+from homeassistant.helpers import (
+    condition,
+    config_validation as cv,
+    entity_registry as er,
+)
 from homeassistant.helpers.config_validation import DEVICE_CONDITION_BASE_SCHEMA
 from homeassistant.helpers.entity import get_capability, get_supported_features
 from homeassistant.helpers.typing import ConfigType, TemplateVarsType
@@ -45,11 +49,11 @@ async def async_get_conditions(
     hass: HomeAssistant, device_id: str
 ) -> list[dict[str, str]]:
     """List device conditions for Climate devices."""
-    registry = entity_registry.async_get(hass)
+    registry = er.async_get(hass)
     conditions = []
 
     # Get all the integrations entities for this device
-    for entry in entity_registry.async_entries_for_device(registry, device_id):
+    for entry in er.async_entries_for_device(registry, device_id):
         if entry.domain != DOMAIN:
             continue
 

homeassistant/components/climate/device_trigger.py

@@ -20,7 +20,7 @@ from homeassistant.const import (
     PERCENTAGE,
 )
 from homeassistant.core import CALLBACK_TYPE, HomeAssistant
-from homeassistant.helpers import config_validation as cv, entity_registry
+from homeassistant.helpers import config_validation as cv, entity_registry as er
 from homeassistant.helpers.trigger import TriggerActionType, TriggerInfo
 from homeassistant.helpers.typing import ConfigType
 
@@ -62,11 +62,11 @@ async def async_get_triggers(
     hass: HomeAssistant, device_id: str
 ) -> list[dict[str, str]]:
     """List device triggers for Climate devices."""
-    registry = entity_registry.async_get(hass)
+    registry = er.async_get(hass)
     triggers = []
 
     # Get all the integrations entities for this device
-    for entry in entity_registry.async_entries_for_device(registry, device_id):
+    for entry in er.async_entries_for_device(registry, device_id):
         if entry.domain != DOMAIN:
             continue
 

homeassistant/components/coinbase/__init__.py

@@ -10,8 +10,7 @@ from coinbase.wallet.error import AuthenticationError
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_API_KEY, CONF_API_TOKEN, Platform
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers import entity_registry
-import homeassistant.helpers.config_validation as cv
+from homeassistant.helpers import config_validation as cv, entity_registry as er
 from homeassistant.util import Throttle
 
 from .const import (
@@ -71,10 +70,8 @@ async def update_listener(hass: HomeAssistant, config_entry: ConfigEntry) -> Non
 
     await hass.config_entries.async_reload(config_entry.entry_id)
 
-    registry = entity_registry.async_get(hass)
-    entities = entity_registry.async_entries_for_config_entry(
-        registry, config_entry.entry_id
-    )
+    registry = er.async_get(hass)
+    entities = er.async_entries_for_config_entry(registry, config_entry.entry_id)
 
     # Remove orphaned entities
     for entity in entities:

homeassistant/components/config/automation.py

@@ -8,7 +8,7 @@ from homeassistant.components.automation.config import (
 )
 from homeassistant.config import AUTOMATION_CONFIG_PATH
 from homeassistant.const import CONF_ID, SERVICE_RELOAD
-from homeassistant.helpers import config_validation as cv, entity_registry
+from homeassistant.helpers import config_validation as cv, entity_registry as er
 
 from . import ACTION_DELETE, EditIdBasedConfigView
 
@@ -23,7 +23,7 @@ async def async_setup(hass):
         if action != ACTION_DELETE:
             return
 
-        ent_reg = entity_registry.async_get(hass)
+        ent_reg = er.async_get(hass)
 
         entity_id = ent_reg.async_get_entity_id(DOMAIN, DOMAIN, config_key)
 

homeassistant/components/config/scene.py

@@ -5,7 +5,7 @@ from homeassistant.components.scene import DOMAIN, PLATFORM_SCHEMA
 from homeassistant.config import SCENE_CONFIG_PATH
 from homeassistant.const import CONF_ID, SERVICE_RELOAD
 from homeassistant.core import DOMAIN as HA_DOMAIN
-from homeassistant.helpers import config_validation as cv, entity_registry
+from homeassistant.helpers import config_validation as cv, entity_registry as er
 
 from . import ACTION_DELETE, EditIdBasedConfigView
 
@@ -19,7 +19,7 @@ async def async_setup(hass):
             await hass.services.async_call(DOMAIN, SERVICE_RELOAD)
             return
 
-        ent_reg = entity_registry.async_get(hass)
+        ent_reg = er.async_get(hass)
 
         entity_id = ent_reg.async_get_entity_id(DOMAIN, HA_DOMAIN, config_key)
 

homeassistant/components/conversation/default_agent.py

@@ -18,9 +18,9 @@ import yaml
 
 from homeassistant import core, setup
 from homeassistant.helpers import (
-    area_registry,
-    device_registry,
-    entity_registry,
+    area_registry as ar,
+    device_registry as dr,
+    entity_registry as er,
     intent,
     template,
     translation,
@@ -95,12 +95,12 @@ class DefaultAgent(AbstractConversationAgent):
             self._config_intents = config_intents
 
         self.hass.bus.async_listen(
-            area_registry.EVENT_AREA_REGISTRY_UPDATED,
+            ar.EVENT_AREA_REGISTRY_UPDATED,
             self._async_handle_area_registry_changed,
             run_immediately=True,
         )
         self.hass.bus.async_listen(
-            entity_registry.EVENT_ENTITY_REGISTRY_UPDATED,
+            er.EVENT_ENTITY_REGISTRY_UPDATED,
             self._async_handle_entity_registry_changed,
             run_immediately=True,
         )
@@ -257,9 +257,9 @@ class DefaultAgent(AbstractConversationAgent):
         # This is available in the response template as "state".
         state1: core.State | None = None
         if intent_response.matched_states:
-            state1 = intent_response.matched_states[0]
+            state1 = matched[0]
         elif intent_response.unmatched_states:
-            state1 = intent_response.unmatched_states[0]
+            state1 = unmatched[0]
 
         # Render response template
         speech = response_template.async_render(
@@ -471,8 +471,8 @@ class DefaultAgent(AbstractConversationAgent):
         states = [
             state for state in self.hass.states.async_all() if is_entity_exposed(state)
         ]
-        entities = entity_registry.async_get(self.hass)
-        devices = device_registry.async_get(self.hass)
+        entities = er.async_get(self.hass)
+        devices = dr.async_get(self.hass)
 
         # Gather exposed entity names
         entity_names = []
@@ -512,7 +512,7 @@ class DefaultAgent(AbstractConversationAgent):
                 entity_names.append((state.name, state.name, context))
 
         # Gather areas from exposed entities
-        areas = area_registry.async_get(self.hass)
+        areas = ar.async_get(self.hass)
         area_names = []
         for area_id in area_ids_with_entities:
             area = areas.async_get_area(area_id)

homeassistant/components/conversation/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "system",
   "iot_class": "local_push",
   "quality_scale": "internal",
-  "requirements": ["hassil==1.0.5", "home-assistant-intents==2023.2.22"]
+  "requirements": ["hassil==1.0.6", "home-assistant-intents==2023.2.28"]
 }

homeassistant/components/coronavirus/__init__.py

@@ -8,7 +8,11 @@ import coronavirus
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers import aiohttp_client, entity_registry, update_coordinator
+from homeassistant.helpers import (
+    aiohttp_client,
+    entity_registry as er,
+    update_coordinator,
+)
 from homeassistant.helpers.typing import ConfigType
 
 from .const import DOMAIN
@@ -31,16 +35,14 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         )
 
         @callback
-        def _async_migrator(entity_entry: entity_registry.RegistryEntry):
+        def _async_migrator(entity_entry: er.RegistryEntry):
             """Migrate away from unstable ID."""
             country, info_type = entity_entry.unique_id.rsplit("-", 1)
             if not country.isnumeric():
                 return None
             return {"new_unique_id": f"{entry.title}-{info_type}"}
 
-        await entity_registry.async_migrate_entries(
-            hass, entry.entry_id, _async_migrator
-        )
+        await er.async_migrate_entries(hass, entry.entry_id, _async_migrator)
 
     if not entry.unique_id:
         hass.config_entries.async_update_entry(entry, unique_id=entry.data["country"])

homeassistant/components/cover/device_action.py

@@ -18,7 +18,7 @@ from homeassistant.const import (
     SERVICE_STOP_COVER,
 )
 from homeassistant.core import Context, HomeAssistant
-from homeassistant.helpers import entity_registry
+from homeassistant.helpers import entity_registry as er
 import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.entity import get_supported_features
 from homeassistant.helpers.typing import ConfigType, TemplateVarsType
@@ -63,11 +63,11 @@ async def async_get_actions(
     hass: HomeAssistant, device_id: str
 ) -> list[dict[str, str]]:
     """List device actions for Cover devices."""
-    registry = entity_registry.async_get(hass)
+    registry = er.async_get(hass)
     actions = []
 
     # Get all the integrations entities for this device
-    for entry in entity_registry.async_entries_for_device(registry, device_id):
+    for entry in er.async_entries_for_device(registry, device_id):
         if entry.domain != DOMAIN:
             continue
 

homeassistant/components/cover/device_condition.py

@@ -18,7 +18,11 @@ from homeassistant.const import (
     STATE_OPENING,
 )
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers import condition, config_validation as cv, entity_registry
+from homeassistant.helpers import (
+    condition,
+    config_validation as cv,
+    entity_registry as er,
+)
 from homeassistant.helpers.config_validation import DEVICE_CONDITION_BASE_SCHEMA
 from homeassistant.helpers.entity import get_supported_features
 from homeassistant.helpers.typing import ConfigType, TemplateVarsType
@@ -66,11 +70,11 @@ async def async_get_conditions(
     hass: HomeAssistant, device_id: str
 ) -> list[dict[str, str]]:
     """List device conditions for Cover devices."""
-    registry = entity_registry.async_get(hass)
+    registry = er.async_get(hass)
     conditions: list[dict[str, str]] = []
 
     # Get all the integrations entities for this device
-    for entry in entity_registry.async_entries_for_device(registry, device_id):
+    for entry in er.async_entries_for_device(registry, device_id):
         if entry.domain != DOMAIN:
             continue
 

homeassistant/components/cover/device_trigger.py

@@ -24,7 +24,7 @@ from homeassistant.const import (
     STATE_OPENING,
 )
 from homeassistant.core import CALLBACK_TYPE, HomeAssistant
-from homeassistant.helpers import config_validation as cv, entity_registry
+from homeassistant.helpers import config_validation as cv, entity_registry as er
 from homeassistant.helpers.entity import get_supported_features
 from homeassistant.helpers.trigger import TriggerActionType, TriggerInfo
 from homeassistant.helpers.typing import ConfigType
@@ -71,11 +71,11 @@ async def async_get_triggers(
     hass: HomeAssistant, device_id: str
 ) -> list[dict[str, str]]:
     """List device triggers for Cover devices."""
-    registry = entity_registry.async_get(hass)
+    registry = er.async_get(hass)
     triggers = []
 
     # Get all the integrations entities for this device
-    for entry in entity_registry.async_entries_for_device(registry, device_id):
+    for entry in er.async_entries_for_device(registry, device_id):
         if entry.domain != DOMAIN:
             continue
 

homeassistant/components/deluge/sensor.py

@@ -14,7 +14,7 @@ from homeassistant.components.sensor import (
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import STATE_IDLE, Platform, UnitOfDataRate
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers import entity_platform
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.typing import StateType
 
 from . import DelugeEntity
@@ -71,9 +71,7 @@ SENSOR_TYPES: tuple[DelugeSensorEntityDescription, ...] = (
 
 
 async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: ConfigEntry,
-    async_add_entities: entity_platform.AddEntitiesCallback,
+    hass: HomeAssistant, entry: ConfigEntry, async_add_entities: AddEntitiesCallback
 ) -> None:
     """Set up the Deluge sensor."""
     async_add_entities(

homeassistant/components/deluge/switch.py

@@ -7,7 +7,7 @@ from homeassistant.components.switch import SwitchEntity
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers import entity_platform
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
 
 from . import DelugeEntity
 from .const import DOMAIN
@@ -15,9 +15,7 @@ from .coordinator import DelugeDataUpdateCoordinator
 
 
 async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: ConfigEntry,
-    async_add_entities: entity_platform.AddEntitiesCallback,
+    hass: HomeAssistant, entry: ConfigEntry, async_add_entities: AddEntitiesCallback
 ) -> None:
     """Set up the Deluge switch."""
     async_add_entities([DelugeSwitch(hass.data[DOMAIN][entry.entry_id])])

homeassistant/components/derivative/sensor.py

@@ -8,11 +8,7 @@ from typing import TYPE_CHECKING
 
 import voluptuous as vol
 
-from homeassistant.components.sensor import (
-    PLATFORM_SCHEMA,
-    SensorEntity,
-    SensorStateClass,
-)
+from homeassistant.components.sensor import PLATFORM_SCHEMA, SensorEntity
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
     ATTR_UNIT_OF_MEASUREMENT,
@@ -135,7 +131,6 @@ class DerivativeSensor(RestoreEntity, SensorEntity):
 
     _attr_icon = ICON
     _attr_should_poll = False
-    _attr_state_class = SensorStateClass.MEASUREMENT
 
     def __init__(
         self,

homeassistant/components/device_tracker/device_condition.py

@@ -13,7 +13,11 @@ from homeassistant.const import (
     STATE_HOME,
 )
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers import condition, config_validation as cv, entity_registry
+from homeassistant.helpers import (
+    condition,
+    config_validation as cv,
+    entity_registry as er,
+)
 from homeassistant.helpers.config_validation import DEVICE_CONDITION_BASE_SCHEMA
 from homeassistant.helpers.typing import ConfigType, TemplateVarsType
 
@@ -33,11 +37,11 @@ async def async_get_conditions(
     hass: HomeAssistant, device_id: str
 ) -> list[dict[str, str]]:
     """List device conditions for Device tracker devices."""
-    registry = entity_registry.async_get(hass)
+    registry = er.async_get(hass)
     conditions = []
 
     # Get all the integrations entities for this device
-    for entry in entity_registry.async_entries_for_device(registry, device_id):
+    for entry in er.async_entries_for_device(registry, device_id):
         if entry.domain != DOMAIN:
             continue
 

homeassistant/components/device_tracker/device_trigger.py

@@ -17,7 +17,7 @@ from homeassistant.const import (
     CONF_ZONE,
 )
 from homeassistant.core import CALLBACK_TYPE, HomeAssistant
-from homeassistant.helpers import config_validation as cv, entity_registry
+from homeassistant.helpers import config_validation as cv, entity_registry as er
 from homeassistant.helpers.trigger import TriggerActionType, TriggerInfo
 from homeassistant.helpers.typing import ConfigType
 
@@ -38,11 +38,11 @@ async def async_get_triggers(
     hass: HomeAssistant, device_id: str
 ) -> list[dict[str, str]]:
     """List device triggers for Device Tracker devices."""
-    registry = entity_registry.async_get(hass)
+    registry = er.async_get(hass)
     triggers = []
 
     # Get all the integrations entities for this device
-    for entry in entity_registry.async_entries_for_device(registry, device_id):
+    for entry in er.async_entries_for_device(registry, device_id):
         if entry.domain != DOMAIN:
             continue
 

homeassistant/components/devolo_home_network/device_tracker.py

@@ -12,7 +12,7 @@ from homeassistant.components.device_tracker import (
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import STATE_UNKNOWN, UnitOfFrequency
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers import entity_registry
+from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.update_coordinator import (
     CoordinatorEntity,
@@ -30,7 +30,7 @@ async def async_setup_entry(
     coordinators: dict[
         str, DataUpdateCoordinator[list[ConnectedStationInfo]]
     ] = hass.data[DOMAIN][entry.entry_id]["coordinators"]
-    registry = entity_registry.async_get(hass)
+    registry = er.async_get(hass)
     tracked = set()
 
     @callback
@@ -53,9 +53,7 @@ async def async_setup_entry(
     def restore_entities() -> None:
         """Restore clients that are not a part of active clients list."""
         missing = []
-        for entity in entity_registry.async_entries_for_config_entry(
-            registry, entry.entry_id
-        ):
+        for entity in er.async_entries_for_config_entry(registry, entry.entry_id):
             if (
                 entity.platform == DOMAIN
                 and entity.domain == DEVICE_TRACKER_DOMAIN

homeassistant/components/dlna_dmr/config_flow.py

@@ -21,8 +21,7 @@ from homeassistant.const import CONF_DEVICE_ID, CONF_HOST, CONF_MAC, CONF_TYPE,
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.data_entry_flow import FlowResult
 from homeassistant.exceptions import IntegrationError
-from homeassistant.helpers import device_registry
-import homeassistant.helpers.config_validation as cv
+from homeassistant.helpers import config_validation as cv, device_registry as dr
 
 from .const import (
     CONF_BROWSE_UNFILTERED,
@@ -501,4 +500,4 @@ async def _async_get_mac_address(hass: HomeAssistant, host: str) -> str | None:
     if not mac_address:
         return None
 
-    return device_registry.format_mac(mac_address)
+    return dr.format_mac(mac_address)

homeassistant/components/dlna_dmr/media_player.py

@@ -29,7 +29,7 @@ from homeassistant.components.media_player import (
 )
 from homeassistant.const import CONF_DEVICE_ID, CONF_MAC, CONF_TYPE, CONF_URL
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers import device_registry, entity_registry
+from homeassistant.helpers import device_registry as dr, entity_registry as er
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 
 from .const import (
@@ -363,21 +363,21 @@ class DlnaDmrEntity(MediaPlayerEntity):
         # device's UDN. They may be the same, if the DMR is the root device.
         connections.add(
             (
-                device_registry.CONNECTION_UPNP,
+                dr.CONNECTION_UPNP,
                 self._device.profile_device.root_device.udn,
             )
         )
-        connections.add((device_registry.CONNECTION_UPNP, self._device.udn))
+        connections.add((dr.CONNECTION_UPNP, self._device.udn))
 
         if self.mac_address:
             # Connection based on MAC address, if known
             connections.add(
                 # Device MAC is obtained from the config entry, which uses getmac
-                (device_registry.CONNECTION_NETWORK_MAC, self.mac_address)
+                (dr.CONNECTION_NETWORK_MAC, self.mac_address)
             )
 
         # Create linked HA DeviceEntry now the information is known.
-        dev_reg = device_registry.async_get(self.hass)
+        dev_reg = dr.async_get(self.hass)
         device_entry = dev_reg.async_get_or_create(
             config_entry_id=self.registry_entry.config_entry_id,
             connections=connections,
@@ -388,7 +388,7 @@ class DlnaDmrEntity(MediaPlayerEntity):
         )
 
         # Update entity registry to link to the device
-        ent_reg = entity_registry.async_get(self.hass)
+        ent_reg = er.async_get(self.hass)
         ent_reg.async_get_or_create(
             self.registry_entry.domain,
             self.registry_entry.platform,

homeassistant/components/dormakaba_dkey/__init__.py

@@ -19,7 +19,7 @@ from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, Upda
 from .const import CONF_ASSOCIATION_DATA, DOMAIN, UPDATE_SECONDS
 from .models import DormakabaDkeyData
 
-PLATFORMS: list[Platform] = [Platform.LOCK, Platform.SENSOR]
+PLATFORMS: list[Platform] = [Platform.BINARY_SENSOR, Platform.LOCK, Platform.SENSOR]
 
 _LOGGER = logging.getLogger(__name__)
 

homeassistant/components/dormakaba_dkey/config_flow.py

@@ -132,7 +132,8 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
 
         try:
             association_data = await lock.associate(user_input["activation_code"])
-        except BleakError:
+        except BleakError as err:
+            _LOGGER.warning("BleakError", exc_info=err)
             return self.async_abort(reason="cannot_connect")
         except dkey_errors.InvalidActivationCode:
             errors["base"] = "invalid_code"

homeassistant/components/dormakaba_dkey/manifest.json

@@ -11,5 +11,5 @@
   "documentation": "https://www.home-assistant.io/integrations/dormakaba_dkey",
   "integration_type": "device",
   "iot_class": "local_polling",
-  "requirements": ["py-dormakaba-dkey==1.0.2"]
+  "requirements": ["py-dormakaba-dkey==1.0.3"]
 }

homeassistant/components/efergy/sensor.py

@@ -16,7 +16,7 @@ from homeassistant.components.sensor import (
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import UnitOfEnergy, UnitOfPower
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers import entity_platform
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.typing import StateType
 
 from . import EfergyEntity
@@ -104,9 +104,7 @@ SENSOR_TYPES: tuple[SensorEntityDescription, ...] = (
 
 
 async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: ConfigEntry,
-    async_add_entities: entity_platform.AddEntitiesCallback,
+    hass: HomeAssistant, entry: ConfigEntry, async_add_entities: AddEntitiesCallback
 ) -> None:
     """Set up Efergy sensors."""
     api: Efergy = hass.data[DOMAIN][entry.entry_id]

homeassistant/components/eight_sleep/sensor.py

@@ -15,7 +15,10 @@ from homeassistant.components.sensor import (
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import PERCENTAGE, UnitOfTemperature
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers import entity_platform as ep
+from homeassistant.helpers.entity_platform import (
+    AddEntitiesCallback,
+    async_get_current_platform,
+)
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 
 from . import EightSleepBaseEntity, EightSleepConfigEntryData
@@ -68,7 +71,7 @@ SERVICE_EIGHT_SCHEMA = {
 
 
 async def async_setup_entry(
-    hass: HomeAssistant, entry: ConfigEntry, async_add_entities: ep.AddEntitiesCallback
+    hass: HomeAssistant, entry: ConfigEntry, async_add_entities: AddEntitiesCallback
 ) -> None:
     """Set up the eight sleep sensors."""
     config_entry_data: EightSleepConfigEntryData = hass.data[DOMAIN][entry.entry_id]
@@ -95,7 +98,7 @@ async def async_setup_entry(
 
     async_add_entities(all_sensors)
 
-    platform = ep.async_get_current_platform()
+    platform = async_get_current_platform()
     platform.async_register_entity_service(
         SERVICE_HEAT_SET,
         SERVICE_EIGHT_SCHEMA,

homeassistant/components/enocean/switch.py

@@ -9,8 +9,7 @@ import voluptuous as vol
 from homeassistant.components.switch import PLATFORM_SCHEMA, SwitchEntity
 from homeassistant.const import CONF_ID, CONF_NAME, Platform
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers import entity_registry
-import homeassistant.helpers.config_validation as cv
+from homeassistant.helpers import config_validation as cv, entity_registry as er
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 
@@ -38,7 +37,7 @@ def _migrate_to_new_unique_id(hass: HomeAssistant, dev_id, channel) -> None:
     """Migrate old unique ids to new unique ids."""
     old_unique_id = f"{combine_hex(dev_id)}"
 
-    ent_reg = entity_registry.async_get(hass)
+    ent_reg = er.async_get(hass)
     entity_id = ent_reg.async_get_entity_id(Platform.SWITCH, DOMAIN, old_unique_id)
 
     if entity_id is not None:

homeassistant/components/entur_public_transport/sensor.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 from datetime import datetime, timedelta
+from random import randint
 
 from enturclient import EnturPublicTransportData
 import voluptuous as vol
@@ -22,7 +23,7 @@ from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 from homeassistant.util import Throttle
 import homeassistant.util.dt as dt_util
 
-API_CLIENT_NAME = "homeassistant-homeassistant"
+API_CLIENT_NAME = "homeassistant-{}"
 
 CONF_STOP_IDS = "stop_ids"
 CONF_EXPAND_PLATFORMS = "expand_platforms"
@@ -105,7 +106,7 @@ async def async_setup_platform(
     quays = [s for s in stop_ids if "Quay" in s]
 
     data = EnturPublicTransportData(
-        API_CLIENT_NAME,
+        API_CLIENT_NAME.format(str(randint(100000, 999999))),
         stops=stops,
         quays=quays,
         line_whitelist=line_whitelist,

homeassistant/components/ezviz/camera.py

@@ -17,10 +17,10 @@ from homeassistant.config_entries import (
 )
 from homeassistant.const import CONF_IP_ADDRESS, CONF_PASSWORD, CONF_USERNAME
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers import (
-    config_validation as cv,
-    discovery_flow,
-    entity_platform,
+from homeassistant.helpers import config_validation as cv, discovery_flow
+from homeassistant.helpers.entity_platform import (
+    AddEntitiesCallback,
+    async_get_current_platform,
 )
 
 from .const import (
@@ -53,9 +53,7 @@ _LOGGER = logging.getLogger(__name__)
 
 
 async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: ConfigEntry,
-    async_add_entities: entity_platform.AddEntitiesCallback,
+    hass: HomeAssistant, entry: ConfigEntry, async_add_entities: AddEntitiesCallback
 ) -> None:
     """Set up EZVIZ cameras based on a config entry."""
 
@@ -132,7 +130,7 @@ async def async_setup_entry(
 
     async_add_entities(camera_entities)
 
-    platform = entity_platform.async_get_current_platform()
+    platform = async_get_current_platform()
 
     platform.async_register_entity_service(
         SERVICE_PTZ,

homeassistant/components/fan/device_condition.py

@@ -14,7 +14,11 @@ from homeassistant.const import (
     STATE_ON,
 )
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers import condition, config_validation as cv, entity_registry
+from homeassistant.helpers import (
+    condition,
+    config_validation as cv,
+    entity_registry as er,
+)
 from homeassistant.helpers.config_validation import DEVICE_CONDITION_BASE_SCHEMA
 from homeassistant.helpers.typing import ConfigType, TemplateVarsType
 
@@ -34,11 +38,11 @@ async def async_get_conditions(
     hass: HomeAssistant, device_id: str
 ) -> list[dict[str, str]]:
     """List device conditions for Fan devices."""
-    registry = entity_registry.async_get(hass)
+    registry = er.async_get(hass)
     conditions = []
 
     # Get all the integrations entities for this device
-    for entry in entity_registry.async_entries_for_device(registry, device_id):
+    for entry in er.async_entries_for_device(registry, device_id):
         if entry.domain != DOMAIN:
             continue
 

homeassistant/components/fitbit/sensor.py

@@ -27,7 +27,7 @@ from homeassistant.helpers.icon import icon_for_battery_level
 from homeassistant.helpers.json import save_json
 from homeassistant.helpers.network import NoURLAvailableError, get_url
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
-from homeassistant.util.json import load_json
+from homeassistant.util.json import load_json_object
 from homeassistant.util.unit_system import METRIC_SYSTEM
 
 from .const import (
@@ -85,7 +85,7 @@ def request_app_setup(
         """Handle configuration updates."""
         config_path = hass.config.path(FITBIT_CONFIG_FILE)
         if os.path.isfile(config_path):
-            config_file = load_json(config_path)
+            config_file = load_json_object(config_path)
             if config_file == DEFAULT_CONFIG:
                 error_msg = (
                     f"You didn't correctly modify {FITBIT_CONFIG_FILE}, please try"
@@ -161,7 +161,7 @@ def setup_platform(
     """Set up the Fitbit sensor."""
     config_path = hass.config.path(FITBIT_CONFIG_FILE)
     if os.path.isfile(config_path):
-        config_file: ConfigType = cast(ConfigType, load_json(config_path))
+        config_file = load_json_object(config_path)
         if config_file == DEFAULT_CONFIG:
             request_app_setup(
                 hass, config, add_entities, config_path, discovery_info=None
@@ -175,13 +175,10 @@ def setup_platform(
     if "fitbit" in _CONFIGURING:
         configurator.request_done(hass, _CONFIGURING.pop("fitbit"))
 
-    access_token: str | None = config_file.get(ATTR_ACCESS_TOKEN)
-    refresh_token: str | None = config_file.get(ATTR_REFRESH_TOKEN)
-    expires_at: int | None = config_file.get(ATTR_LAST_SAVED_AT)
     if (
-        access_token is not None
-        and refresh_token is not None
-        and expires_at is not None
+        (access_token := config_file.get(ATTR_ACCESS_TOKEN)) is not None
+        and (refresh_token := config_file.get(ATTR_REFRESH_TOKEN)) is not None
+        and (expires_at := config_file.get(ATTR_LAST_SAVED_AT)) is not None
     ):
         authd_client = Fitbit(
             config_file.get(CONF_CLIENT_ID),
@@ -192,7 +189,7 @@ def setup_platform(
             refresh_cb=lambda x: None,
         )
 
-        if int(time.time()) - expires_at > 3600:
+        if int(time.time()) - cast(int, expires_at) > 3600:
             authd_client.client.refresh_token()
 
         user_profile = authd_client.user_profile_get()["user"]

homeassistant/components/frontend/__init__.py

@@ -341,11 +341,6 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     is_dev = repo_path is not None
     root_path = _frontend_root(repo_path)
 
-    if is_dev:
-        from .dev import async_setup_frontend_dev
-
-        async_setup_frontend_dev(hass)
-
     for path, should_cache in (
         ("service_worker.js", False),
         ("robots.txt", False),

homeassistant/components/frontend/dev.py

@@ -1,60 +0,0 @@
-"""Development helpers for the frontend."""
-import aiohttp
-from aiohttp import hdrs, web
-
-from homeassistant.components.http.view import HomeAssistantView
-from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers import aiohttp_client
-
-
-@callback
-def async_setup_frontend_dev(hass: HomeAssistant) -> None:
-    """Set up frontend dev views."""
-    hass.http.register_view(  # type: ignore
-        FrontendDevView(
-            "http://localhost:8000", aiohttp_client.async_get_clientsession(hass)
-        )
-    )
-
-
-FILTER_RESPONSE_HEADERS = {hdrs.CONTENT_LENGTH, hdrs.CONTENT_ENCODING}
-
-
-class FrontendDevView(HomeAssistantView):
-    """Frontend dev view."""
-
-    name = "_dev:frontend"
-    url = "/_dev_frontend/{path:.*}"
-    requires_auth = False
-    extra_urls = ["/__web-dev-server__/{path:.*}"]
-
-    def __init__(self, forward_base: str, websession: aiohttp.ClientSession):
-        """Initialize a Hass.io ingress view."""
-        self._forward_base = forward_base
-        self._websession = websession
-
-    async def get(self, request: web.Request, path: str) -> web.Response:
-        """Frontend routing."""
-        # To deal with: import * as commonjsHelpers from '/__web-dev-server__/rollup/commonjsHelpers.js
-        if request.path.startswith("/__web-dev-server__/"):
-            path = f"__web-dev-server__/{path}"
-
-        url = f"{self._forward_base}/{path}"
-
-        if request.query_string:
-            url += f"?{request.query_string}"
-
-        async with self._websession.get(
-            url,
-            headers=request.headers,
-            allow_redirects=False,
-        ) as result:
-            return web.Response(
-                headers={
-                    hdr: val
-                    for hdr, val in result.headers.items()
-                    if hdr not in FILTER_RESPONSE_HEADERS
-                },
-                status=result.status,
-                body=await result.read(),
-            )

homeassistant/components/geniushub/climate.py

@@ -79,10 +79,10 @@ class GeniusClimateZone(GeniusHeatingZone, ClimateEntity):
     def hvac_action(self) -> str | None:
         """Return the current running hvac operation if supported."""
         if "_state" in self._zone.data:  # only for v3 API
+            if self._zone.data["output"] == 1:
+                return HVACAction.HEATING
             if not self._zone.data["_state"].get("bIsActive"):
                 return HVACAction.OFF
-            if self._zone.data["_state"].get("bOutRequestHeat"):
-                return HVACAction.HEATING
             return HVACAction.IDLE
         return None
 

homeassistant/components/geofency/device_tracker.py

@@ -3,7 +3,7 @@ from homeassistant.components.device_tracker import SourceType, TrackerEntity
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import ATTR_LATITUDE, ATTR_LONGITUDE
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers import device_registry
+from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity import DeviceInfo
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
@@ -34,7 +34,7 @@ async def async_setup_entry(
     ] = async_dispatcher_connect(hass, TRACKER_UPDATE, _receive_data)
 
     # Restore previously loaded devices
-    dev_reg = device_registry.async_get(hass)
+    dev_reg = dr.async_get(hass)
     dev_ids = {
         identifier[1]
         for device in dev_reg.devices.values()

homeassistant/components/glances/sensor.py

@@ -21,7 +21,7 @@ from homeassistant.const import (
     UnitOfTemperature,
 )
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers import entity_registry
+from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.entity import DeviceInfo
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
@@ -257,7 +257,7 @@ async def async_setup_entry(
         hass: HomeAssistant, old_unique_id: str, new_key: str
     ) -> None:
         """Migrate unique IDs to the new format."""
-        ent_reg = entity_registry.async_get(hass)
+        ent_reg = er.async_get(hass)
 
         if entity_id := ent_reg.async_get_entity_id(
             Platform.SENSOR, DOMAIN, old_unique_id

homeassistant/components/google_assistant/helpers.py

@@ -22,7 +22,12 @@ from homeassistant.const import (
     STATE_UNAVAILABLE,
 )
 from homeassistant.core import Context, HomeAssistant, State, callback
-from homeassistant.helpers import area_registry, device_registry, entity_registry, start
+from homeassistant.helpers import (
+    area_registry as ar,
+    device_registry as dr,
+    entity_registry as er,
+    start,
+)
 from homeassistant.helpers.event import async_call_later
 from homeassistant.helpers.network import get_url
 from homeassistant.helpers.storage import Store
@@ -52,15 +57,11 @@ LOCAL_SDK_MIN_VERSION = AwesomeVersion("2.1.5")
 @callback
 def _get_registry_entries(
     hass: HomeAssistant, entity_id: str
-) -> tuple[
-    entity_registry.RegistryEntry | None,
-    device_registry.DeviceEntry | None,
-    area_registry.AreaEntry | None,
-]:
+) -> tuple[er.RegistryEntry | None, dr.DeviceEntry | None, ar.AreaEntry | None,]:
     """Get registry entries."""
-    ent_reg = entity_registry.async_get(hass)
-    dev_reg = device_registry.async_get(hass)
-    area_reg = area_registry.async_get(hass)
+    ent_reg = er.async_get(hass)
+    dev_reg = dr.async_get(hass)
+    area_reg = ar.async_get(hass)
 
     if (entity_entry := ent_reg.async_get(entity_id)) and entity_entry.device_id:
         device_entry = dev_reg.devices.get(entity_entry.device_id)

homeassistant/components/google_assistant/trait.py

@@ -832,7 +832,7 @@ class TemperatureControlTrait(_Trait):
             "temperatureUnitForUX": _google_temp_unit(
                 self.hass.config.units.temperature_unit
             ),
-            "queryOnlyTemperatureSetting": True,
+            "queryOnlyTemperatureControl": True,
             "temperatureRange": {
                 "minThresholdCelsius": -100,
                 "maxThresholdCelsius": 100,

homeassistant/components/gpslogger/device_tracker.py

@@ -8,7 +8,7 @@ from homeassistant.const import (
     ATTR_LONGITUDE,
 )
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers import device_registry
+from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity import DeviceInfo
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
@@ -44,7 +44,7 @@ async def async_setup_entry(
     ] = async_dispatcher_connect(hass, TRACKER_UPDATE, _receive_data)
 
     # Restore previously loaded devices
-    dev_reg = device_registry.async_get(hass)
+    dev_reg = dr.async_get(hass)
     dev_ids = {
         identifier[1]
         for device in dev_reg.devices.values()

homeassistant/components/guardian/util.py

@@ -12,7 +12,7 @@ from aioguardian.errors import GuardianError
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers import entity_registry
+from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
@@ -41,7 +41,7 @@ def async_finish_entity_domain_replacements(
     entity_replacement_strategies: Iterable[EntityDomainReplacementStrategy],
 ) -> None:
     """Remove old entities and create a repairs issue with info on their replacement."""
-    ent_reg = entity_registry.async_get(hass)
+    ent_reg = er.async_get(hass)
     for strategy in entity_replacement_strategies:
         try:
             [registry_entry] = [

homeassistant/components/harmony/__init__.py

@@ -5,7 +5,7 @@ from homeassistant.components.remote import ATTR_ACTIVITY, ATTR_DELAY_SECS
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_HOST, CONF_NAME, EVENT_HOMEASSISTANT_STOP
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers import entity_registry
+from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.dispatcher import async_dispatcher_send
 
 from .const import (
@@ -60,7 +60,7 @@ async def _migrate_old_unique_ids(
     names_to_ids = {activity["label"]: activity["id"] for activity in data.activities}
 
     @callback
-    def _async_migrator(entity_entry: entity_registry.RegistryEntry):
+    def _async_migrator(entity_entry: er.RegistryEntry):
         # Old format for switches was {remote_unique_id}-{activity_name}
         # New format is activity_{activity_id}
         parts = entity_entry.unique_id.split("-", 1)
@@ -78,7 +78,7 @@ async def _migrate_old_unique_ids(
 
         return None
 
-    await entity_registry.async_migrate_entries(hass, entry_id, _async_migrator)
+    await er.async_migrate_entries(hass, entry_id, _async_migrator)
 
 
 @callback

homeassistant/components/homekit/__init__.py

@@ -50,8 +50,12 @@ from homeassistant.const import (
 )
 from homeassistant.core import CoreState, HomeAssistant, ServiceCall, State, callback
 from homeassistant.exceptions import HomeAssistantError, Unauthorized
-from homeassistant.helpers import device_registry, entity_registry, instance_id
-import homeassistant.helpers.config_validation as cv
+from homeassistant.helpers import (
+    config_validation as cv,
+    device_registry as dr,
+    entity_registry as er,
+    instance_id,
+)
 from homeassistant.helpers.entityfilter import (
     BASE_FILTER_SCHEMA,
     FILTER_SCHEMA,
@@ -431,20 +435,19 @@ def _async_register_events_and_services(hass: HomeAssistant) -> None:
     async def async_handle_homekit_unpair(service: ServiceCall) -> None:
         """Handle unpair HomeKit service call."""
         referenced = async_extract_referenced_entity_ids(hass, service)
-        dev_reg = device_registry.async_get(hass)
+        dev_reg = dr.async_get(hass)
         for device_id in referenced.referenced_devices:
             if not (dev_reg_ent := dev_reg.async_get(device_id)):
                 raise HomeAssistantError(f"No device found for device id: {device_id}")
             macs = [
                 cval
                 for ctype, cval in dev_reg_ent.connections
-                if ctype == device_registry.CONNECTION_NETWORK_MAC
+                if ctype == dr.CONNECTION_NETWORK_MAC
             ]
             matching_instances = [
                 homekit
                 for homekit in _async_all_homekit_instances(hass)
-                if homekit.driver
-                and device_registry.format_mac(homekit.driver.state.mac) in macs
+                if homekit.driver and dr.format_mac(homekit.driver.state.mac) in macs
             ]
             if not matching_instances:
                 raise HomeAssistantError(
@@ -698,7 +701,7 @@ class HomeKit:
         return False
 
     def add_bridge_triggers_accessory(
-        self, device: device_registry.DeviceEntry, device_triggers: list[dict[str, Any]]
+        self, device: dr.DeviceEntry, device_triggers: list[dict[str, Any]]
     ) -> None:
         """Add device automation triggers to the bridge."""
         if self._would_exceed_max_devices(device.name):
@@ -734,8 +737,8 @@ class HomeKit:
 
     async def async_configure_accessories(self) -> list[State]:
         """Configure accessories for the included states."""
-        dev_reg = device_registry.async_get(self.hass)
-        ent_reg = entity_registry.async_get(self.hass)
+        dev_reg = dr.async_get(self.hass)
+        ent_reg = er.async_get(self.hass)
         device_lookup = ent_reg.async_get_device_class_lookup(
             {
                 (BINARY_SENSOR_DOMAIN, BinarySensorDeviceClass.BATTERY_CHARGING),
@@ -830,8 +833,8 @@ class HomeKit:
     def _async_register_bridge(self) -> None:
         """Register the bridge as a device so homekit_controller and exclude it from discovery."""
         assert self.driver is not None
-        dev_reg = device_registry.async_get(self.hass)
-        formatted_mac = device_registry.format_mac(self.driver.state.mac)
+        dev_reg = dr.async_get(self.hass)
+        formatted_mac = dr.format_mac(self.driver.state.mac)
         # Connections and identifiers are both used here.
         #
         # connections exists so homekit_controller can know the
@@ -844,7 +847,7 @@ class HomeKit:
         # because this was the way you had to fix homekit when pairing
         # failed.
         #
-        connection = (device_registry.CONNECTION_NETWORK_MAC, formatted_mac)
+        connection = (dr.CONNECTION_NETWORK_MAC, formatted_mac)
         identifier = (DOMAIN, self._entry_id, BRIDGE_SERIAL_NUMBER)
         self._async_purge_old_bridges(dev_reg, identifier, connection)
         is_accessory_mode = self._homekit_mode == HOMEKIT_MODE_ACCESSORY
@@ -858,13 +861,13 @@ class HomeKit:
             manufacturer=MANUFACTURER,
             name=accessory_friendly_name(self._entry_title, self.driver.accessory),
             model=f"HomeKit {hk_mode_name}",
-            entry_type=device_registry.DeviceEntryType.SERVICE,
+            entry_type=dr.DeviceEntryType.SERVICE,
         )
 
     @callback
     def _async_purge_old_bridges(
         self,
-        dev_reg: device_registry.DeviceRegistry,
+        dev_reg: dr.DeviceRegistry,
         identifier: tuple[str, str, str],
         connection: tuple[str, str],
     ) -> None:
@@ -920,7 +923,7 @@ class HomeKit:
 
     async def _async_add_trigger_accessories(self) -> None:
         """Add devices with triggers to the bridge."""
-        dev_reg = device_registry.async_get(self.hass)
+        dev_reg = dr.async_get(self.hass)
         valid_device_ids = []
         for device_id in self._devices:
             if not dev_reg.async_get(device_id):
@@ -989,7 +992,7 @@ class HomeKit:
     @callback
     def _async_configure_linked_sensors(
         self,
-        ent_reg_ent: entity_registry.RegistryEntry,
+        ent_reg_ent: er.RegistryEntry,
         device_lookup: dict[str, dict[tuple[str, str | None], str]],
         state: State,
     ) -> None:
@@ -1051,8 +1054,8 @@ class HomeKit:
 
     async def _async_set_device_info_attributes(
         self,
-        ent_reg_ent: entity_registry.RegistryEntry,
-        dev_reg: device_registry.DeviceRegistry,
+        ent_reg_ent: er.RegistryEntry,
+        dev_reg: dr.DeviceRegistry,
         entity_id: str,
     ) -> None:
         """Set attributes that will be used for homekit device info."""
@@ -1070,7 +1073,7 @@ class HomeKit:
                 ent_cfg[ATTR_INTEGRATION] = ent_reg_ent.platform
 
     def _fill_config_from_device_registry_entry(
-        self, device_entry: device_registry.DeviceEntry, config: dict[str, Any]
+        self, device_entry: dr.DeviceEntry, config: dict[str, Any]
     ) -> None:
         """Populate a config dict from the registry."""
         if device_entry.manufacturer:

homeassistant/components/homekit/config_flow.py

@@ -28,8 +28,11 @@ from homeassistant.const import (
 )
 from homeassistant.core import HomeAssistant, callback, split_entity_id
 from homeassistant.data_entry_flow import FlowResult
-from homeassistant.helpers import device_registry, entity_registry
-import homeassistant.helpers.config_validation as cv
+from homeassistant.helpers import (
+    config_validation as cv,
+    device_registry as dr,
+    entity_registry as er,
+)
 from homeassistant.helpers.entityfilter import (
     CONF_EXCLUDE_DOMAINS,
     CONF_EXCLUDE_ENTITIES,
@@ -630,7 +633,7 @@ async def _async_get_supported_devices(hass: HomeAssistant) -> dict[str, str]:
     results = await device_automation.async_get_device_automations(
         hass, device_automation.DeviceAutomationType.TRIGGER
     )
-    dev_reg = device_registry.async_get(hass)
+    dev_reg = dr.async_get(hass)
     unsorted: dict[str, str] = {}
     for device_id in results:
         entry = dev_reg.async_get(device_id)
@@ -639,7 +642,7 @@ async def _async_get_supported_devices(hass: HomeAssistant) -> dict[str, str]:
 
 
 def _exclude_by_entity_registry(
-    ent_reg: entity_registry.EntityRegistry,
+    ent_reg: er.EntityRegistry,
     entity_id: str,
     include_entity_category: bool,
     include_hidden: bool,
@@ -661,7 +664,7 @@ def _async_get_matching_entities(
     include_hidden: bool = False,
 ) -> dict[str, str]:
     """Fetch all entities or entities in the given domains."""
-    ent_reg = entity_registry.async_get(hass)
+    ent_reg = er.async_get(hass)
     return {
         state.entity_id: (
             f"{state.attributes.get(ATTR_FRIENDLY_NAME, state.entity_id)} ({state.entity_id})"

homeassistant/components/homekit/type_triggers.py

@@ -7,7 +7,7 @@ from typing import Any
 from pyhap.const import CATEGORY_SENSOR
 
 from homeassistant.core import CALLBACK_TYPE, Context
-from homeassistant.helpers import entity_registry
+from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.trigger import async_initialize_triggers
 
 from .accessories import TYPES, HomeAccessory
@@ -42,7 +42,7 @@ class DeviceTriggerAccessory(HomeAccessory):
         self._remove_triggers: CALLBACK_TYPE | None = None
         self.triggers = []
         assert device_triggers is not None
-        ent_reg = entity_registry.async_get(self.hass)
+        ent_reg = er.async_get(self.hass)
         for idx, trigger in enumerate(device_triggers):
             type_: str = trigger["type"]
             subtype: str | None = trigger.get("subtype")

homeassistant/components/honeywell/climate.py

@@ -421,6 +421,7 @@ class HoneywellUSThermostat(ClimateEntity):
         """Get the latest state from the service."""
         try:
             await self._device.refresh()
+            self._attr_available = True
         except (
             aiosomecomfort.SomeComfortError,
             OSError,
@@ -428,8 +429,10 @@ class HoneywellUSThermostat(ClimateEntity):
             try:
                 await self._data.client.login()
 
-            except aiosomecomfort.SomeComfortError:
+            except aiosomecomfort.AuthError:
                 self._attr_available = False
                 await self.hass.async_create_task(
                     self.hass.config_entries.async_reload(self._data.entry_id)
                 )
+            except aiosomecomfort.SomeComfortError:
+                self._attr_available = False

homeassistant/components/honeywell/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/honeywell",
   "iot_class": "cloud_polling",
   "loggers": ["somecomfort"],
-  "requirements": ["aiosomecomfort==0.0.10"]
+  "requirements": ["aiosomecomfort==0.0.11"]
 }

homeassistant/components/http/security_filter.py

@@ -5,6 +5,7 @@ from collections.abc import Awaitable, Callable
 import logging
 import re
 from typing import Final
+from urllib.parse import unquote
 
 from aiohttp.web import Application, HTTPBadRequest, Request, StreamResponse, middleware
 
@@ -39,18 +40,24 @@ FILTERS: Final = re.compile(
 def setup_security_filter(app: Application) -> None:
     """Create security filter middleware for the app."""
 
+    def _recursive_unquote(value: str) -> str:
+        """Handle values that are encoded multiple times."""
+        if (unquoted := unquote(value)) != value:
+            unquoted = _recursive_unquote(unquoted)
+        return unquoted
+
     @middleware
     async def security_filter_middleware(
         request: Request, handler: Callable[[Request], Awaitable[StreamResponse]]
     ) -> StreamResponse:
-        """Process request and tblock commonly known exploit attempts."""
-        if FILTERS.search(request.path):
+        """Process request and block commonly known exploit attempts."""
+        if FILTERS.search(_recursive_unquote(request.path)):
             _LOGGER.warning(
                 "Filtered a potential harmful request to: %s", request.raw_path
             )
             raise HTTPBadRequest
 
-        if FILTERS.search(request.query_string):
+        if FILTERS.search(_recursive_unquote(request.query_string)):
             _LOGGER.warning(
                 "Filtered a request with a potential harmful query string: %s",
                 request.raw_path,

homeassistant/components/huawei_lte/__init__.py

@@ -44,7 +44,7 @@ from homeassistant.helpers import (
     config_validation as cv,
     device_registry as dr,
     discovery,
-    entity_registry,
+    entity_registry as er,
 )
 from homeassistant.helpers.dispatcher import async_dispatcher_connect, dispatcher_send
 from homeassistant.helpers.entity import DeviceInfo, Entity
@@ -359,8 +359,8 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         # Transitional from < 2021.8: update None config entry and entity unique ids
         if router_info and (serial_number := router_info.get("SerialNumber")):
             hass.config_entries.async_update_entry(entry, unique_id=serial_number)
-            ent_reg = entity_registry.async_get(hass)
-            for entity_entry in entity_registry.async_entries_for_config_entry(
+            ent_reg = er.async_get(hass)
+            for entity_entry in er.async_entries_for_config_entry(
                 ent_reg, entry.entry_id
             ):
                 if not entity_entry.unique_id.startswith("None-"):

homeassistant/components/huawei_lte/device_tracker.py

@@ -15,7 +15,7 @@ from homeassistant.components.device_tracker import (
 )
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers import entity_registry
+from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity import Entity
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
@@ -66,7 +66,7 @@ async def async_setup_entry(
 
     # Initialize already tracked entities
     tracked: set[str] = set()
-    registry = entity_registry.async_get(hass)
+    registry = er.async_get(hass)
     known_entities: list[Entity] = []
     track_wired_clients = router.config_entry.options.get(
         CONF_TRACK_WIRED_CLIENTS, DEFAULT_TRACK_WIRED_CLIENTS

homeassistant/components/hue/config_flow.py

@@ -18,8 +18,11 @@ from homeassistant.components import zeroconf
 from homeassistant.const import CONF_API_KEY, CONF_HOST
 from homeassistant.core import callback
 from homeassistant.data_entry_flow import FlowResult
-from homeassistant.helpers import aiohttp_client, device_registry
-import homeassistant.helpers.config_validation as cv
+from homeassistant.helpers import (
+    aiohttp_client,
+    config_validation as cv,
+    device_registry as dr,
+)
 from homeassistant.util.network import is_ipv6_address
 
 from .const import (
@@ -306,10 +309,8 @@ class HueV2OptionsFlowHandler(config_entries.OptionsFlow):
 
         # create a list of Hue device ID's that the user can select
         # to ignore availability status
-        dev_reg = device_registry.async_get(self.hass)
-        entries = device_registry.async_entries_for_config_entry(
-            dev_reg, self.config_entry.entry_id
-        )
+        dev_reg = dr.async_get(self.hass)
+        entries = dr.async_entries_for_config_entry(dev_reg, self.config_entry.entry_id)
         dev_ids = {
             identifier[1]: entry.name
             for entry in entries

homeassistant/components/hue/logbook.py

@@ -35,6 +35,7 @@ TRIGGER_TYPE = {
     "remote_double_button_long_press": "both {subtype} released after long press",
     "remote_double_button_short_press": "both {subtype} released",
     "initial_press": "{subtype} pressed initially",
+    "long_press": "{subtype} long press",
     "repeat": "{subtype} held down",
     "short_release": "{subtype} released after short press",
     "long_release": "{subtype} released after long press",

homeassistant/components/hue/manifest.json

@@ -11,6 +11,6 @@
   "iot_class": "local_push",
   "loggers": ["aiohue"],
   "quality_scale": "platinum",
-  "requirements": ["aiohue==4.6.1"],
+  "requirements": ["aiohue==4.6.2"],
   "zeroconf": ["_hue._tcp.local."]
 }

homeassistant/components/hue/scene.py

@@ -13,9 +13,12 @@ import voluptuous as vol
 from homeassistant.components.scene import ATTR_TRANSITION, Scene as SceneEntity
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers import entity_platform
 from homeassistant.helpers.device_registry import DeviceEntryType
 from homeassistant.helpers.entity import DeviceInfo
+from homeassistant.helpers.entity_platform import (
+    AddEntitiesCallback,
+    async_get_current_platform,
+)
 
 from .bridge import HueBridge
 from .const import DOMAIN
@@ -31,7 +34,7 @@ ATTR_BRIGHTNESS = "brightness"
 async def async_setup_entry(
     hass: HomeAssistant,
     config_entry: ConfigEntry,
-    async_add_entities: entity_platform.AddEntitiesCallback,
+    async_add_entities: AddEntitiesCallback,
 ) -> None:
     """Set up scene platform from Hue group scenes."""
     bridge: HueBridge = hass.data[DOMAIN][config_entry.entry_id]
@@ -62,7 +65,7 @@ async def async_setup_entry(
     )
 
     # add platform service to turn_on/activate scene with advanced options
-    platform = entity_platform.async_get_current_platform()
+    platform = async_get_current_platform()
     platform.async_register_entity_service(
         SERVICE_ACTIVATE_SCENE,
         {
@@ -118,13 +121,14 @@ class HueSceneEntityBase(HueBaseEntity, SceneEntity):
         """Return device (service) info."""
         # we create a virtual service/device for Hue scenes
         # so we have a parent for grouped lights and scenes
+        group_type = self.group.type.value.title()
         return DeviceInfo(
             identifiers={(DOMAIN, self.group.id)},
             entry_type=DeviceEntryType.SERVICE,
             name=self.group.metadata.name,
             manufacturer=self.bridge.api.config.bridge_device.product_data.manufacturer_name,
             model=self.group.type.value.title(),
-            suggested_area=self.group.metadata.name,
+            suggested_area=self.group.metadata.name if group_type == "Room" else None,
             via_device=(DOMAIN, self.bridge.api.config.bridge_device.id),
         )
 

homeassistant/components/hue/v2/device.py

@@ -16,7 +16,7 @@ from homeassistant.const import (
     ATTR_VIA_DEVICE,
 )
 from homeassistant.core import callback
-from homeassistant.helpers import device_registry
+from homeassistant.helpers import device_registry as dr
 
 from ..const import DOMAIN
 
@@ -29,11 +29,11 @@ async def async_setup_devices(bridge: "HueBridge"):
     entry = bridge.config_entry
     hass = bridge.hass
     api: HueBridgeV2 = bridge.api  # to satisfy typing
-    dev_reg = device_registry.async_get(hass)
+    dev_reg = dr.async_get(hass)
     dev_controller = api.devices
 
     @callback
-    def add_device(hue_device: Device) -> device_registry.DeviceEntry:
+    def add_device(hue_device: Device) -> dr.DeviceEntry:
         """Register a Hue device in device registry."""
         model = f"{hue_device.product_data.product_name} ({hue_device.product_data.model_id})"
         params = {
@@ -51,9 +51,7 @@ async def async_setup_devices(bridge: "HueBridge"):
             params[ATTR_VIA_DEVICE] = (DOMAIN, api.config.bridge_device.id)
         zigbee = dev_controller.get_zigbee_connectivity(hue_device.id)
         if zigbee and zigbee.mac_address:
-            params[ATTR_CONNECTIONS] = {
-                (device_registry.CONNECTION_NETWORK_MAC, zigbee.mac_address)
-            }
+            params[ATTR_CONNECTIONS] = {(dr.CONNECTION_NETWORK_MAC, zigbee.mac_address)}
 
         return dev_reg.async_get_or_create(config_entry_id=entry.entry_id, **params)
 
@@ -77,9 +75,7 @@ async def async_setup_devices(bridge: "HueBridge"):
     known_devices = [add_device(hue_device) for hue_device in dev_controller]
 
     # Check for nodes that no longer exist and remove them
-    for device in device_registry.async_entries_for_config_entry(
-        dev_reg, entry.entry_id
-    ):
+    for device in dr.async_entries_for_config_entry(dev_reg, entry.entry_id):
         if device not in known_devices:
             # handle case where a virtual device was created for a Hue group
             hue_dev_id = next(x[1] for x in device.identifiers if x[0] == DOMAIN)

homeassistant/components/hue/v2/device_trigger.py

@@ -46,6 +46,7 @@ DEFAULT_BUTTON_EVENT_TYPES = (
     ButtonEvent.INITIAL_PRESS,
     ButtonEvent.REPEAT,
     ButtonEvent.SHORT_RELEASE,
+    ButtonEvent.LONG_PRESS,
     ButtonEvent.LONG_RELEASE,
 )
 

homeassistant/components/hue/v2/entity.py

@@ -55,7 +55,13 @@ class HueBaseEntity(Entity):
         self._attr_unique_id = resource.id
         # device is precreated in main handler
         # this attaches the entity to the precreated device
-        if self.device is not None:
+        if self.device is None:
+            # attach all device-less entities to the bridge itself
+            # e.g. config based sensors like entertainment area
+            self._attr_device_info = DeviceInfo(
+                identifiers={(DOMAIN, bridge.api.config.bridge.bridge_id)},
+            )
+        else:
             self._attr_device_info = DeviceInfo(
                 identifiers={(DOMAIN, self.device.id)},
             )
@@ -137,17 +143,14 @@ class HueBaseEntity(Entity):
     def _handle_event(self, event_type: EventType, resource: HueResource) -> None:
         """Handle status event for this resource (or it's parent)."""
         if event_type == EventType.RESOURCE_DELETED:
-            # remove any services created for zones/rooms
+            # handle removal of room and zone 'virtual' devices/services
             # regular devices are removed automatically by the logic in device.py.
             if resource.type in (ResourceTypes.ROOM, ResourceTypes.ZONE):
                 dev_reg = async_get_device_registry(self.hass)
                 if device := dev_reg.async_get_device({(DOMAIN, resource.id)}):
                     dev_reg.async_remove_device(device.id)
-            if resource.type in (
-                ResourceTypes.GROUPED_LIGHT,
-                ResourceTypes.SCENE,
-                ResourceTypes.SMART_SCENE,
-            ):
+            # cleanup entities that are not strictly device-bound and have the bridge as parent
+            if self.device is None:
                 ent_reg = async_get_entity_registry(self.hass)
                 ent_reg.async_remove(self.entity_id)
             return

homeassistant/components/hue/v2/hue_event.py

@@ -9,7 +9,7 @@ from aiohue.v2.models.relative_rotary import RelativeRotary
 
 from homeassistant.const import CONF_DEVICE_ID, CONF_ID, CONF_TYPE, CONF_UNIQUE_ID
 from homeassistant.core import callback
-from homeassistant.helpers import device_registry
+from homeassistant.helpers import device_registry as dr
 from homeassistant.util import slugify
 
 from ..const import ATTR_HUE_EVENT, CONF_SUBTYPE, DOMAIN
@@ -29,7 +29,7 @@ async def async_setup_hue_events(bridge: "HueBridge"):
     hass = bridge.hass
     api: HueBridgeV2 = bridge.api  # to satisfy typing
     conf_entry = bridge.config_entry
-    dev_reg = device_registry.async_get(hass)
+    dev_reg = dr.async_get(hass)
 
     btn_controller = api.sensors.button
     rotary_controller = api.sensors.relative_rotary

homeassistant/components/huisbaasje/const.py

@@ -8,14 +8,10 @@ from energyflip.const import (
     SOURCE_TYPE_GAS,
 )
 
-from homeassistant.const import UnitOfTime, UnitOfVolume
-
 DATA_COORDINATOR = "coordinator"
 
 DOMAIN = "huisbaasje"
 
-FLOW_CUBIC_METERS_PER_HOUR = f"{UnitOfVolume.CUBIC_METERS}/{UnitOfTime.HOURS}"
-
 """Interval in seconds between polls to huisbaasje."""
 POLLING_INTERVAL = 20
 

homeassistant/components/huisbaasje/sensor.py

@@ -21,7 +21,13 @@ from homeassistant.components.sensor import (
     SensorStateClass,
 )
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_ID, UnitOfEnergy, UnitOfPower, UnitOfVolume
+from homeassistant.const import (
+    CONF_ID,
+    UnitOfEnergy,
+    UnitOfPower,
+    UnitOfVolume,
+    UnitOfVolumeFlowRate,
+)
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.update_coordinator import (
@@ -32,7 +38,6 @@ from homeassistant.helpers.update_coordinator import (
 from .const import (
     DATA_COORDINATOR,
     DOMAIN,
-    FLOW_CUBIC_METERS_PER_HOUR,
     SENSOR_TYPE_RATE,
     SENSOR_TYPE_THIS_DAY,
     SENSOR_TYPE_THIS_MONTH,
@@ -179,7 +184,7 @@ SENSORS_INFO = [
     ),
     HuisbaasjeSensorEntityDescription(
         name="Huisbaasje Current Gas",
-        native_unit_of_measurement=FLOW_CUBIC_METERS_PER_HOUR,
+        native_unit_of_measurement=UnitOfVolumeFlowRate.CUBIC_METERS_PER_HOUR,
         sensor_type=SENSOR_TYPE_RATE,
         state_class=SensorStateClass.MEASUREMENT,
         key=SOURCE_TYPE_GAS,

homeassistant/components/humidifier/device_action.py

@@ -14,7 +14,7 @@ from homeassistant.const import (
 )
 from homeassistant.core import Context, HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers import entity_registry
+from homeassistant.helpers import entity_registry as er
 import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.entity import get_capability, get_supported_features
 from homeassistant.helpers.typing import ConfigType, TemplateVarsType
@@ -48,11 +48,11 @@ async def async_get_actions(
     hass: HomeAssistant, device_id: str
 ) -> list[dict[str, str]]:
     """List device actions for Humidifier devices."""
-    registry = entity_registry.async_get(hass)
+    registry = er.async_get(hass)
     actions = await toggle_entity.async_get_actions(hass, device_id, DOMAIN)
 
     # Get all the integrations entities for this device
-    for entry in entity_registry.async_entries_for_device(registry, device_id):
+    for entry in er.async_entries_for_device(registry, device_id):
         if entry.domain != DOMAIN:
             continue
 

homeassistant/components/humidifier/device_condition.py

@@ -15,7 +15,11 @@ from homeassistant.const import (
 )
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers import condition, config_validation as cv, entity_registry
+from homeassistant.helpers import (
+    condition,
+    config_validation as cv,
+    entity_registry as er,
+)
 from homeassistant.helpers.config_validation import DEVICE_CONDITION_BASE_SCHEMA
 from homeassistant.helpers.entity import get_capability, get_supported_features
 from homeassistant.helpers.typing import ConfigType, TemplateVarsType
@@ -41,11 +45,11 @@ async def async_get_conditions(
     hass: HomeAssistant, device_id: str
 ) -> list[dict[str, str]]:
     """List device conditions for Humidifier devices."""
-    registry = entity_registry.async_get(hass)
+    registry = er.async_get(hass)
     conditions = await toggle_entity.async_get_conditions(hass, device_id, DOMAIN)
 
     # Get all the integrations entities for this device
-    for entry in entity_registry.async_entries_for_device(registry, device_id):
+    for entry in er.async_entries_for_device(registry, device_id):
         if entry.domain != DOMAIN:
             continue
 

homeassistant/components/humidifier/device_trigger.py

@@ -22,7 +22,7 @@ from homeassistant.const import (
     PERCENTAGE,
 )
 from homeassistant.core import CALLBACK_TYPE, HomeAssistant
-from homeassistant.helpers import config_validation as cv, entity_registry
+from homeassistant.helpers import config_validation as cv, entity_registry as er
 from homeassistant.helpers.trigger import TriggerActionType, TriggerInfo
 from homeassistant.helpers.typing import ConfigType
 
@@ -56,11 +56,11 @@ async def async_get_triggers(
     hass: HomeAssistant, device_id: str
 ) -> list[dict[str, str]]:
     """List device triggers for Humidifier devices."""
-    registry = entity_registry.async_get(hass)
+    registry = er.async_get(hass)
     triggers = await toggle_entity.async_get_triggers(hass, device_id, DOMAIN)
 
     # Get all the integrations entities for this device
-    for entry in entity_registry.async_entries_for_device(registry, device_id):
+    for entry in er.async_entries_for_device(registry, device_id):
         if entry.domain != DOMAIN:
             continue
 

homeassistant/components/insteon/manifest.json

@@ -17,7 +17,7 @@
   "iot_class": "local_push",
   "loggers": ["pyinsteon", "pypubsub"],
   "requirements": [
-    "pyinsteon==1.3.2",
+    "pyinsteon==1.3.3",
     "insteon-frontend-home-assistant==0.3.2"
   ],
   "usb": [

homeassistant/components/intent/__init__.py

@@ -18,7 +18,7 @@ from homeassistant.const import (
 )
 from homeassistant.core import DOMAIN as HA_DOMAIN, HomeAssistant, State
 from homeassistant.helpers import (
-    area_registry,
+    area_registry as ar,
     config_validation as cv,
     integration_platform,
     intent,
@@ -109,9 +109,9 @@ class GetStateIntentHandler(intent.IntentHandler):
 
         # Look up area first to fail early
         area_name = slots.get("area", {}).get("value")
-        area: area_registry.AreaEntry | None = None
+        area: ar.AreaEntry | None = None
         if area_name is not None:
-            areas = area_registry.async_get(hass)
+            areas = ar.async_get(hass)
             area = areas.async_get_area(area_name) or areas.async_get_area_by_name(
                 area_name
             )

homeassistant/components/iotawatt/sensor.py

@@ -24,8 +24,7 @@ from homeassistant.const import (
     UnitOfPower,
 )
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers import entity, entity_registry
-from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC
+from homeassistant.helpers import device_registry as dr, entity, entity_registry as er
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.typing import StateType
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
@@ -186,7 +185,9 @@ class IotaWattSensor(CoordinatorEntity[IotawattUpdater], SensorEntity):
     def device_info(self) -> entity.DeviceInfo:
         """Return device info."""
         return entity.DeviceInfo(
-            connections={(CONNECTION_NETWORK_MAC, self._sensor_data.hub_mac_address)},
+            connections={
+                (dr.CONNECTION_NETWORK_MAC, self._sensor_data.hub_mac_address)
+            },
             manufacturer="IoTaWatt",
             model="IoTaWatt",
         )
@@ -196,7 +197,7 @@ class IotaWattSensor(CoordinatorEntity[IotawattUpdater], SensorEntity):
         """Handle updated data from the coordinator."""
         if self._key not in self.coordinator.data["sensors"]:
             if self._attr_unique_id:
-                entity_registry.async_get(self.hass).async_remove(self.entity_id)
+                er.async_get(self.hass).async_remove(self.entity_id)
             else:
                 self.hass.async_create_task(self.async_remove())
             return

homeassistant/components/ipma/weather.py

@@ -43,7 +43,7 @@ from homeassistant.const import (
     UnitOfTemperature,
 )
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers import entity_registry
+from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.sun import is_up
 from homeassistant.util import Throttle
@@ -89,7 +89,7 @@ async def async_setup_entry(
 
     # Migrate old unique_id
     @callback
-    def _async_migrator(entity_entry: entity_registry.RegistryEntry):
+    def _async_migrator(entity_entry: er.RegistryEntry):
         # Reject if new unique_id
         if entity_entry.unique_id.count(",") == 2:
             return None
@@ -105,9 +105,7 @@ async def async_setup_entry(
         )
         return {"new_unique_id": new_unique_id}
 
-    await entity_registry.async_migrate_entries(
-        hass, config_entry.entry_id, _async_migrator
-    )
+    await er.async_migrate_entries(hass, config_entry.entry_id, _async_migrator)
 
     async_add_entities([IPMAWeather(location, api, config_entry.data)], True)
 

homeassistant/components/keenetic_ndms2/__init__.py

@@ -6,7 +6,7 @@ import logging
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_HOST, CONF_SCAN_INTERVAL, Platform
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers import device_registry, entity_registry
+from homeassistant.helpers import device_registry as dr, entity_registry as er
 
 from .const import (
     CONF_CONSIDER_HOME,
@@ -67,8 +67,8 @@ async def async_unload_entry(hass: HomeAssistant, config_entry: ConfigEntry) ->
         _LOGGER.debug(
             "Cleaning device_tracker entities since some interfaces are now untracked:"
         )
-        ent_reg = entity_registry.async_get(hass)
-        dev_reg = device_registry.async_get(hass)
+        ent_reg = er.async_get(hass)
+        dev_reg = dr.async_get(hass)
         # We keep devices currently connected to new_tracked_interfaces
         keep_devices: set[str] = {
             mac

homeassistant/components/keenetic_ndms2/device_tracker.py

@@ -12,7 +12,7 @@ from homeassistant.components.device_tracker import (
 )
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers import entity_registry
+from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 import homeassistant.util.dt as dt_util
@@ -40,7 +40,7 @@ async def async_setup_entry(
 
     update_from_router()
 
-    registry = entity_registry.async_get(hass)
+    registry = er.async_get(hass)
     # Restore devices that are not a part of active clients list.
     restored = []
     for entity_entry in registry.entities.values():

homeassistant/components/keymitt_ble/switch.py

@@ -8,7 +8,11 @@ import voluptuous as vol
 from homeassistant.components.switch import SwitchEntity
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers import config_validation as cv, entity_platform
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.entity_platform import (
+    AddEntitiesCallback,
+    async_get_current_platform,
+)
 
 from .const import DOMAIN
 from .coordinator import MicroBotDataUpdateCoordinator
@@ -23,14 +27,12 @@ CALIBRATE_SCHEMA = {
 
 
 async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: ConfigEntry,
-    async_add_entities: entity_platform.AddEntitiesCallback,
+    hass: HomeAssistant, entry: ConfigEntry, async_add_entities: AddEntitiesCallback
 ) -> None:
     """Set up MicroBot based on a config entry."""
     coordinator: MicroBotDataUpdateCoordinator = hass.data[DOMAIN][entry.entry_id]
     async_add_entities([MicroBotBinarySwitch(coordinator, entry)])
-    platform = entity_platform.async_get_current_platform()
+    platform = async_get_current_platform()
     platform.async_register_entity_service(
         CALIBRATE,
         CALIBRATE_SCHEMA,

homeassistant/components/kodi/device_trigger.py

@@ -13,7 +13,7 @@ from homeassistant.const import (
     CONF_TYPE,
 )
 from homeassistant.core import CALLBACK_TYPE, Event, HassJob, HomeAssistant, callback
-from homeassistant.helpers import config_validation as cv, entity_registry
+from homeassistant.helpers import config_validation as cv, entity_registry as er
 from homeassistant.helpers.trigger import TriggerActionType, TriggerInfo
 from homeassistant.helpers.typing import ConfigType
 
@@ -33,11 +33,11 @@ async def async_get_triggers(
     hass: HomeAssistant, device_id: str
 ) -> list[dict[str, str]]:
     """List device triggers for Kodi devices."""
-    registry = entity_registry.async_get(hass)
+    registry = er.async_get(hass)
     triggers = []
 
     # Get all the integrations entities for this device
-    for entry in entity_registry.async_entries_for_device(registry, device_id):
+    for entry in er.async_entries_for_device(registry, device_id):
         if entry.domain == "media_player":
             triggers.append(
                 {

homeassistant/components/kodi/media_player.py

@@ -39,7 +39,7 @@ from homeassistant.const import (
 from homeassistant.core import CoreState, HomeAssistant, callback
 from homeassistant.helpers import (
     config_validation as cv,
-    device_registry,
+    device_registry as dr,
     entity_platform,
 )
 from homeassistant.helpers.entity import DeviceInfo
@@ -407,7 +407,7 @@ class KodiEntity(MediaPlayerEntity):
 
         version = (await self._kodi.get_application_properties(["version"]))["version"]
         sw_version = f"{version['major']}.{version['minor']}"
-        dev_reg = device_registry.async_get(self.hass)
+        dev_reg = dr.async_get(self.hass)
         device = dev_reg.async_get_device({(DOMAIN, self.unique_id)})
         dev_reg.async_update_device(device.id, sw_version=sw_version)
 

homeassistant/components/kraken/sensor.py

@@ -6,7 +6,7 @@ import logging
 from homeassistant.components.sensor import SensorEntity, SensorStateClass
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers import device_registry
+from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity import DeviceInfo
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
@@ -55,11 +55,11 @@ async def async_setup_entry(
     @callback
     def async_update_sensors(hass: HomeAssistant, config_entry: ConfigEntry) -> None:
         """Add or remove sensors for configured tracked asset pairs."""
-        dev_reg = device_registry.async_get(hass)
+        dev_reg = dr.async_get(hass)
 
         existing_devices = {
             device.name: device.id
-            for device in device_registry.async_entries_for_config_entry(
+            for device in dr.async_entries_for_config_entry(
                 dev_reg, config_entry.entry_id
             )
         }
@@ -125,7 +125,7 @@ class KrakenSensor(
 
         self._attr_device_info = DeviceInfo(
             configuration_url="https://www.kraken.com/",
-            entry_type=device_registry.DeviceEntryType.SERVICE,
+            entry_type=dr.DeviceEntryType.SERVICE,
             identifiers={(DOMAIN, "_".join(self._device_name.split(" ")))},
             manufacturer="Kraken.com",
             name=self._device_name,

homeassistant/components/light/intent.py

@@ -9,7 +9,7 @@ import voluptuous as vol
 
 from homeassistant.const import ATTR_ENTITY_ID, SERVICE_TURN_ON
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers import area_registry, config_validation as cv, intent
+from homeassistant.helpers import area_registry as ar, config_validation as cv, intent
 import homeassistant.util.color as color_util
 
 from . import (
@@ -56,9 +56,9 @@ class SetIntentHandler(intent.IntentHandler):
 
         # Look up area first to fail early
         area_name = slots.get("area", {}).get("value")
-        area: area_registry.AreaEntry | None = None
+        area: ar.AreaEntry | None = None
         if area_name is not None:
-            areas = area_registry.async_get(hass)
+            areas = ar.async_get(hass)
             area = areas.async_get_area(area_name) or areas.async_get_area_by_name(
                 area_name
             )

homeassistant/components/livisi/climate.py

@@ -70,6 +70,7 @@ def create_entity(
 ) -> ClimateEntity:
     """Create Climate Entity."""
     capabilities: Mapping[str, Any] = device[CAPABILITY_MAP]
+    config_details: Mapping[str, Any] = device["config"]
     room_id: str = device["location"]
     room_name: str = coordinator.rooms[room_id]
     livisi_climate = LivisiClimate(
@@ -82,6 +83,7 @@ def create_entity(
         temperature_capability=capabilities["RoomTemperature"],
         humidity_capability=capabilities["RoomHumidity"],
         room=room_name,
+        name=config_details["name"],
     )
     return livisi_climate
 
@@ -95,6 +97,7 @@ class LivisiClimate(CoordinatorEntity[LivisiDataUpdateCoordinator], ClimateEntit
     _attr_supported_features = ClimateEntityFeature.TARGET_TEMPERATURE
     _attr_target_temperature_high = MAX_TEMPERATURE
     _attr_target_temperature_low = MIN_TEMPERATURE
+    _attr_has_entity_name = True
 
     def __init__(
         self,
@@ -107,6 +110,7 @@ class LivisiClimate(CoordinatorEntity[LivisiDataUpdateCoordinator], ClimateEntit
         temperature_capability: str,
         humidity_capability: str,
         room: str,
+        name: str,
     ) -> None:
         """Initialize the Livisi Climate."""
         self.config_entry = config_entry
@@ -116,6 +120,7 @@ class LivisiClimate(CoordinatorEntity[LivisiDataUpdateCoordinator], ClimateEntit
         self._humidity_capability = humidity_capability
         self.aio_livisi = coordinator.aiolivisi
         self._attr_available = False
+        self._attr_name = name
         self._attr_device_info = DeviceInfo(
             identifiers={(DOMAIN, unique_id)},
             manufacturer=manufacturer,

homeassistant/components/livisi/manifest.json

@@ -1,7 +1,7 @@
 {
   "domain": "livisi",
   "name": "LIVISI Smart Home",
-  "codeowners": ["@StefanIacobLivisi"],
+  "codeowners": ["@StefanIacobLivisi", "@planbnet"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/livisi",
   "iot_class": "local_polling",

homeassistant/components/lock/device_action.py

@@ -14,7 +14,7 @@ from homeassistant.const import (
     SERVICE_UNLOCK,
 )
 from homeassistant.core import Context, HomeAssistant
-from homeassistant.helpers import entity_registry
+from homeassistant.helpers import entity_registry as er
 import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.entity import get_supported_features
 from homeassistant.helpers.typing import ConfigType, TemplateVarsType
@@ -35,11 +35,11 @@ async def async_get_actions(
     hass: HomeAssistant, device_id: str
 ) -> list[dict[str, str]]:
     """List device actions for Lock devices."""
-    registry = entity_registry.async_get(hass)
+    registry = er.async_get(hass)
     actions = []
 
     # Get all the integrations entities for this device
-    for entry in entity_registry.async_entries_for_device(registry, device_id):
+    for entry in er.async_entries_for_device(registry, device_id):
         if entry.domain != DOMAIN:
             continue
 

homeassistant/components/lock/device_condition.py

@@ -17,7 +17,11 @@ from homeassistant.const import (
     STATE_UNLOCKING,
 )
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers import condition, config_validation as cv, entity_registry
+from homeassistant.helpers import (
+    condition,
+    config_validation as cv,
+    entity_registry as er,
+)
 from homeassistant.helpers.config_validation import DEVICE_CONDITION_BASE_SCHEMA
 from homeassistant.helpers.typing import ConfigType, TemplateVarsType
 
@@ -45,11 +49,11 @@ async def async_get_conditions(
     hass: HomeAssistant, device_id: str
 ) -> list[dict[str, str]]:
     """List device conditions for Lock devices."""
-    registry = entity_registry.async_get(hass)
+    registry = er.async_get(hass)
     conditions = []
 
     # Get all the integrations entities for this device
-    for entry in entity_registry.async_entries_for_device(registry, device_id):
+    for entry in er.async_entries_for_device(registry, device_id):
         if entry.domain != DOMAIN:
             continue
 

homeassistant/components/lock/device_trigger.py

@@ -19,7 +19,7 @@ from homeassistant.const import (
     STATE_UNLOCKING,
 )
 from homeassistant.core import CALLBACK_TYPE, HomeAssistant
-from homeassistant.helpers import config_validation as cv, entity_registry
+from homeassistant.helpers import config_validation as cv, entity_registry as er
 from homeassistant.helpers.trigger import TriggerActionType, TriggerInfo
 from homeassistant.helpers.typing import ConfigType
 
@@ -40,11 +40,11 @@ async def async_get_triggers(
     hass: HomeAssistant, device_id: str
 ) -> list[dict[str, str]]:
     """List device triggers for Lock devices."""
-    registry = entity_registry.async_get(hass)
+    registry = er.async_get(hass)
     triggers = []
 
     # Get all the integrations entities for this device
-    for entry in entity_registry.async_entries_for_device(registry, device_id):
+    for entry in er.async_entries_for_device(registry, device_id):
         if entry.domain != DOMAIN:
             continue
 

homeassistant/components/mazda/__init__.py

@@ -24,8 +24,11 @@ from homeassistant.exceptions import (
     ConfigEntryNotReady,
     HomeAssistantError,
 )
-from homeassistant.helpers import aiohttp_client, device_registry
-import homeassistant.helpers.config_validation as cv
+from homeassistant.helpers import (
+    aiohttp_client,
+    config_validation as cv,
+    device_registry as dr,
+)
 from homeassistant.helpers.entity import DeviceInfo
 from homeassistant.helpers.update_coordinator import (
     CoordinatorEntity,
@@ -81,7 +84,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     async def async_handle_service_call(service_call: ServiceCall) -> None:
         """Handle a service call."""
         # Get device entry from device registry
-        dev_reg = device_registry.async_get(hass)
+        dev_reg = dr.async_get(hass)
         device_id = service_call.data["device_id"]
         device_entry = dev_reg.async_get(device_id)
         if TYPE_CHECKING:
@@ -121,7 +124,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 
     def validate_mazda_device_id(device_id):
         """Check that a device ID exists in the registry and has at least one 'mazda' identifier."""
-        dev_reg = device_registry.async_get(hass)
+        dev_reg = dr.async_get(hass)
 
         if (device_entry := dev_reg.async_get(device_id)) is None:
             raise vol.Invalid("Invalid device ID")

homeassistant/components/media_player/device_condition.py

@@ -18,7 +18,11 @@ from homeassistant.const import (
     STATE_PLAYING,
 )
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers import condition, config_validation as cv, entity_registry
+from homeassistant.helpers import (
+    condition,
+    config_validation as cv,
+    entity_registry as er,
+)
 from homeassistant.helpers.config_validation import DEVICE_CONDITION_BASE_SCHEMA
 from homeassistant.helpers.typing import ConfigType, TemplateVarsType
 
@@ -45,11 +49,11 @@ async def async_get_conditions(
     hass: HomeAssistant, device_id: str
 ) -> list[dict[str, str]]:
     """List device conditions for Media player devices."""
-    registry = entity_registry.async_get(hass)
+    registry = er.async_get(hass)
     conditions: list[dict[str, str]] = []
 
     # Get all the integrations entities for this device
-    for entry in entity_registry.async_entries_for_device(registry, device_id):
+    for entry in er.async_entries_for_device(registry, device_id):
         if entry.domain != DOMAIN:
             continue
 

homeassistant/components/media_player/device_trigger.py

@@ -23,7 +23,7 @@ from homeassistant.const import (
     STATE_PLAYING,
 )
 from homeassistant.core import CALLBACK_TYPE, HomeAssistant
-from homeassistant.helpers import config_validation as cv, entity_registry
+from homeassistant.helpers import config_validation as cv, entity_registry as er
 from homeassistant.helpers.trigger import TriggerActionType, TriggerInfo
 from homeassistant.helpers.typing import ConfigType
 
@@ -52,11 +52,11 @@ async def async_get_triggers(
     hass: HomeAssistant, device_id: str
 ) -> list[dict[str, str]]:
     """List device triggers for Media player entities."""
-    registry = entity_registry.async_get(hass)
+    registry = er.async_get(hass)
     triggers = await entity.async_get_triggers(hass, device_id, DOMAIN)
 
     # Get all the integration entities for this device
-    for entry in entity_registry.async_entries_for_device(registry, device_id):
+    for entry in er.async_entries_for_device(registry, device_id):
         if entry.domain != DOMAIN:
             continue
 

homeassistant/components/metoffice/__init__.py

@@ -18,8 +18,7 @@ from homeassistant.const import (
 )
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import ConfigEntryNotReady
-from homeassistant.helpers import entity_registry
-from homeassistant.helpers.device_registry import DeviceEntryType
+from homeassistant.helpers import device_registry as dr, entity_registry as er
 from homeassistant.helpers.entity import DeviceInfo
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 
@@ -53,7 +52,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 
     @callback
     def update_unique_id(
-        entity_entry: entity_registry.RegistryEntry,
+        entity_entry: er.RegistryEntry,
     ) -> dict[str, Any] | None:
         """Update unique ID of entity entry."""
 
@@ -86,7 +85,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
             }
         return None
 
-    await entity_registry.async_migrate_entries(hass, entry.entry_id, update_unique_id)
+    await er.async_migrate_entries(hass, entry.entry_id, update_unique_id)
 
     connection = datapoint.connection(api_key=api_key)
 
@@ -154,7 +153,7 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 def get_device_info(coordinates: str, name: str) -> DeviceInfo:
     """Return device registry information."""
     return DeviceInfo(
-        entry_type=DeviceEntryType.SERVICE,
+        entry_type=dr.DeviceEntryType.SERVICE,
         identifiers={(DOMAIN, coordinates)},
         manufacturer="Met Office",
         name=f"Met Office {name}",

homeassistant/components/mikrotik/device_tracker.py

@@ -10,7 +10,7 @@ from homeassistant.components.device_tracker import (
 )
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers import entity_registry
+from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 import homeassistant.util.dt as dt_util
@@ -31,7 +31,7 @@ async def async_setup_entry(
 
     tracked: dict[str, MikrotikDataUpdateCoordinatorTracker] = {}
 
-    registry = entity_registry.async_get(hass)
+    registry = er.async_get(hass)
 
     # Restore clients that is not a part of active clients list.
     for entity in registry.entities.values():

homeassistant/components/modem_callerid/button.py

@@ -7,15 +7,13 @@ from homeassistant.components.button import ButtonEntity
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_DEVICE
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers import entity_platform
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
 
 from .const import DATA_KEY_API, DOMAIN
 
 
 async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: ConfigEntry,
-    async_add_entities: entity_platform.AddEntitiesCallback,
+    hass: HomeAssistant, entry: ConfigEntry, async_add_entities: AddEntitiesCallback
 ) -> None:
     """Set up the Modem Caller ID sensor."""
     api = hass.data[DOMAIN][entry.entry_id][DATA_KEY_API]

homeassistant/components/modem_callerid/sensor.py

@@ -7,15 +7,13 @@ from homeassistant.components.sensor import SensorEntity
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import EVENT_HOMEASSISTANT_STOP, STATE_IDLE
 from homeassistant.core import Event, HomeAssistant, callback
-from homeassistant.helpers import entity_platform
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
 
 from .const import CID, DATA_KEY_API, DOMAIN, ICON
 
 
 async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: ConfigEntry,
-    async_add_entities: entity_platform.AddEntitiesCallback,
+    hass: HomeAssistant, entry: ConfigEntry, async_add_entities: AddEntitiesCallback
 ) -> None:
     """Set up the Modem Caller ID sensor."""
     api = hass.data[DOMAIN][entry.entry_id][DATA_KEY_API]

homeassistant/components/motion_blinds/config_flow.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 
 from typing import Any
 
-from motionblinds import MotionDiscovery
+from motionblinds import MotionDiscovery, MotionGateway
 import voluptuous as vol
 
 from homeassistant import config_entries
@@ -86,6 +86,16 @@ class MotionBlindsFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
         await self.async_set_unique_id(mac_address)
         self._abort_if_unique_id_configured(updates={CONF_HOST: discovery_info.ip})
 
+        gateway = MotionGateway(ip=discovery_info.ip, key="abcd1234-56ef-78")
+        try:
+            # key not needed for GetDeviceList request
+            await self.hass.async_add_executor_job(gateway.GetDeviceList)
+        except Exception:  # pylint: disable=broad-except
+            return self.async_abort(reason="not_motionblinds")
+
+        if not gateway.available:
+            return self.async_abort(reason="not_motionblinds")
+
         short_mac = mac_address[-6:].upper()
         self.context["title_placeholders"] = {
             "short_mac": short_mac,