evlli/hass-core
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Reduce complexity in the homekit config flow filters (#109850)

Browse source 
* Add typing to entity filters

* Add typing to entity filters

* Add typing to entity filters

* Add typing to entity filters

* tweaks

* tweaks

* tweaks

* tweaks

* tweaks
This commit is contained in:
J. Nick Koston 2024-02-09 08:33:21 -06:00 • committed by GitHub
parent 8e4714c563
commit 206aaac700
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
2 changed files with 125 additions and 113 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

214
homeassistant/components/homekit/config_flow.py
View file

@ -7,7 +7,7 @@ from operator import itemgetter
import random
import re
import string
from typing import Any
from typing import Any, Final, TypedDict
import voluptuous as vol
@ -34,12 +34,6 @@ from homeassistant.helpers import (
device_registry as dr,
entity_registry as er,
)
from homeassistant.helpers.entityfilter import (
CONF_EXCLUDE_DOMAINS,
CONF_EXCLUDE_ENTITIES,
CONF_INCLUDE_DOMAINS,
CONF_INCLUDE_ENTITIES,
)
from homeassistant.loader import async_get_integrations
from .const import (
@ -69,13 +63,13 @@ MODE_EXCLUDE = "exclude"
INCLUDE_EXCLUDE_MODES = [MODE_EXCLUDE, MODE_INCLUDE]
DOMAINS_NEED_ACCESSORY_MODE = [
DOMAINS_NEED_ACCESSORY_MODE = {
CAMERA_DOMAIN,
LOCK_DOMAIN,
MEDIA_PLAYER_DOMAIN,
REMOTE_DOMAIN,
]
NEVER_BRIDGED_DOMAINS = [CAMERA_DOMAIN]
}
NEVER_BRIDGED_DOMAINS = {CAMERA_DOMAIN}
CAMERA_ENTITY_PREFIX = f"{CAMERA_DOMAIN}."
@ -124,12 +118,34 @@ DEFAULT_DOMAINS = [
"water_heater",
]
_EMPTY_ENTITY_FILTER: dict[str, list[str]] = {
CONF_INCLUDE_DOMAINS: [],
CONF_EXCLUDE_DOMAINS: [],
CONF_INCLUDE_ENTITIES: [],
CONF_EXCLUDE_ENTITIES: [],
}
CONF_INCLUDE_DOMAINS: Final = "include_domains"
CONF_INCLUDE_ENTITIES: Final = "include_entities"
CONF_EXCLUDE_DOMAINS: Final = "exclude_domains"
CONF_EXCLUDE_ENTITIES: Final = "exclude_entities"
class EntityFilterDict(TypedDict, total=False):
"""Entity filter dict."""
include_domains: list[str]
include_entities: list[str]
exclude_domains: list[str]
exclude_entities: list[str]
def _make_entity_filter(
include_domains: list[str] | None = None,
include_entities: list[str] | None = None,
exclude_domains: list[str] | None = None,
exclude_entities: list[str] | None = None,
) -> EntityFilterDict:
"""Create a filter dict."""
return EntityFilterDict(
include_domains=include_domains or [],
include_entities=include_entities or [],
exclude_domains=exclude_domains or [],
exclude_entities=exclude_entities or [],
)
async def _async_domain_names(hass: HomeAssistant, domains: list[str]) -> str:
@ -141,19 +157,18 @@ async def _async_domain_names(hass: HomeAssistant, domains: list[str]) -> str:
@callback
def _async_build_entites_filter(
def _async_build_entities_filter(
domains: list[str], entities: list[str]
) -> dict[str, Any]:
) -> EntityFilterDict:
"""Build an entities filter from domains and entities."""
entity_filter = deepcopy(_EMPTY_ENTITY_FILTER)
entity_filter[CONF_INCLUDE_ENTITIES] = entities
# Include all of the domain if there are no entities
# explicitly included as the user selected the domain
domains_with_entities_selected = _domains_set_from_entities(entities)
entity_filter[CONF_INCLUDE_DOMAINS] = [
domain for domain in domains if domain not in domains_with_entities_selected
]
return entity_filter
return _make_entity_filter(
include_domains=sorted(
set(domains).difference(_domains_set_from_entities(entities))
),
include_entities=entities,
)
def _async_cameras_from_entities(entities: list[str]) -> dict[str, str]:
@ -190,13 +205,15 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
) -> FlowResult:
"""Choose specific domains in bridge mode."""
if user_input is not None:
entity_filter = deepcopy(_EMPTY_ENTITY_FILTER)
entity_filter[CONF_INCLUDE_DOMAINS] = user_input[CONF_INCLUDE_DOMAINS]
self.hk_data[CONF_FILTER] = entity_filter
self.hk_data[CONF_FILTER] = _make_entity_filter(
include_domains=user_input[CONF_INCLUDE_DOMAINS]
)
return await self.async_step_pairing()
self.hk_data[CONF_HOMEKIT_MODE] = HOMEKIT_MODE_BRIDGE
default_domains = [] if self._async_current_names() else DEFAULT_DOMAINS
default_domains = (
[] if self._async_current_entries(include_ignore=False) else DEFAULT_DOMAINS
)
name_to_type_map = await _async_name_to_type_map(self.hass)
return self.async_show_form(
step_id="user",
@ -213,24 +230,28 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
"""Pairing instructions."""
hk_data = self.hk_data
if user_input is not None:
port = async_find_next_available_port(self.hass, DEFAULT_CONFIG_FLOW_PORT)
await self._async_add_entries_for_accessory_mode_entities(port)
self.hk_data[CONF_PORT] = port
include_domains_filter = self.hk_data[CONF_FILTER][CONF_INCLUDE_DOMAINS]
for domain in NEVER_BRIDGED_DOMAINS:
if domain in include_domains_filter:
include_domains_filter.remove(domain)
hk_data[CONF_PORT] = port
conf_filter: EntityFilterDict = hk_data[CONF_FILTER]
conf_filter[CONF_INCLUDE_DOMAINS] = [
domain
for domain in conf_filter[CONF_INCLUDE_DOMAINS]
if domain not in NEVER_BRIDGED_DOMAINS
]
return self.async_create_entry(
title=f"{self.hk_data[CONF_NAME]}:{self.hk_data[CONF_PORT]}",
data=self.hk_data,
title=f"{hk_data[CONF_NAME]}:{hk_data[CONF_PORT]}",
data=hk_data,
)
self.hk_data[CONF_NAME] = self._async_available_name(SHORT_BRIDGE_NAME)
self.hk_data[CONF_EXCLUDE_ACCESSORY_MODE] = True
hk_data[CONF_NAME] = self._async_available_name(SHORT_BRIDGE_NAME)
hk_data[CONF_EXCLUDE_ACCESSORY_MODE] = True
return self.async_show_form(
step_id="pairing",
description_placeholders={CONF_NAME: self.hk_data[CONF_NAME]},
description_placeholders={CONF_NAME: hk_data[CONF_NAME]},
)
async def _async_add_entries_for_accessory_mode_entities(
@ -265,14 +286,12 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
state = self.hass.states.get(entity_id)
assert state is not None
name = state.attributes.get(ATTR_FRIENDLY_NAME) or state.entity_id
entity_filter = _EMPTY_ENTITY_FILTER.copy()
entity_filter[CONF_INCLUDE_ENTITIES] = [entity_id]
entry_data = {
CONF_PORT: port,
CONF_NAME: self._async_available_name(name),
CONF_HOMEKIT_MODE: HOMEKIT_MODE_ACCESSORY,
CONF_FILTER: entity_filter,
CONF_FILTER: _make_entity_filter(include_entities=[entity_id]),
}
if entity_id.startswith(CAMERA_ENTITY_PREFIX):
entry_data[CONF_ENTITY_CONFIG] = {
@ -360,26 +379,19 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
"""Choose advanced options."""
if (
not self.show_advanced_options
or user_input is not None
or self.hk_options[CONF_HOMEKIT_MODE] != HOMEKIT_MODE_BRIDGE
):
hk_options = self.hk_options
show_advanced_options = self.show_advanced_options
bridge_mode = hk_options[CONF_HOMEKIT_MODE] == HOMEKIT_MODE_BRIDGE
if not show_advanced_options or user_input is not None or not bridge_mode:
if user_input:
self.hk_options.update(user_input)
if (
self.show_advanced_options
and self.hk_options[CONF_HOMEKIT_MODE] == HOMEKIT_MODE_BRIDGE
):
self.hk_options[CONF_DEVICES] = user_input[CONF_DEVICES]
for key in (CONF_DOMAINS, CONF_ENTITIES):
if key in self.hk_options:
del self.hk_options[key]
if CONF_INCLUDE_EXCLUDE_MODE in self.hk_options:
del self.hk_options[CONF_INCLUDE_EXCLUDE_MODE]
hk_options.update(user_input)
if show_advanced_options and bridge_mode:
hk_options[CONF_DEVICES] = user_input[CONF_DEVICES]
hk_options.pop(CONF_DOMAINS, None)
hk_options.pop(CONF_ENTITIES, None)
hk_options.pop(CONF_INCLUDE_EXCLUDE_MODE, None)
return self.async_create_entry(title="", data=self.hk_options)
all_supported_devices = await _async_get_supported_devices(self.hass)
@ -404,35 +416,37 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
"""Choose camera config."""
hk_options = self.hk_options
all_entity_config: dict[str, dict[str, Any]]
if user_input is not None:
entity_config = self.hk_options[CONF_ENTITY_CONFIG]
all_entity_config = hk_options[CONF_ENTITY_CONFIG]
for entity_id in self.included_cameras:
entity_config = all_entity_config.setdefault(entity_id, {})
if entity_id in user_input[CONF_CAMERA_COPY]:
entity_config.setdefault(entity_id, {})[
CONF_VIDEO_CODEC
] = VIDEO_CODEC_COPY
elif (
entity_id in entity_config
and CONF_VIDEO_CODEC in entity_config[entity_id]
):
del entity_config[entity_id][CONF_VIDEO_CODEC]
entity_config[CONF_VIDEO_CODEC] = VIDEO_CODEC_COPY
elif CONF_VIDEO_CODEC in entity_config:
del entity_config[CONF_VIDEO_CODEC]
if entity_id in user_input[CONF_CAMERA_AUDIO]:
entity_config.setdefault(entity_id, {})[CONF_SUPPORT_AUDIO] = True
elif (
entity_id in entity_config
and CONF_SUPPORT_AUDIO in entity_config[entity_id]
):
del entity_config[entity_id][CONF_SUPPORT_AUDIO]
entity_config[CONF_SUPPORT_AUDIO] = True
elif CONF_SUPPORT_AUDIO in entity_config:
del entity_config[CONF_SUPPORT_AUDIO]
if not entity_config:
all_entity_config.pop(entity_id)
return await self.async_step_advanced()
cameras_with_audio = []
cameras_with_copy = []
entity_config = self.hk_options.setdefault(CONF_ENTITY_CONFIG, {})
all_entity_config = hk_options.setdefault(CONF_ENTITY_CONFIG, {})
for entity in self.included_cameras:
hk_entity_config = entity_config.get(entity, {})
if hk_entity_config.get(CONF_VIDEO_CODEC) == VIDEO_CODEC_COPY:
entity_config = all_entity_config.get(entity, {})
if entity_config.get(CONF_VIDEO_CODEC) == VIDEO_CODEC_COPY:
cameras_with_copy.append(entity)
if hk_entity_config.get(CONF_SUPPORT_AUDIO):
if entity_config.get(CONF_SUPPORT_AUDIO):
cameras_with_audio.append(entity)
data_schema = vol.Schema(
@ -453,18 +467,20 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
"""Choose entity for the accessory."""
domains = self.hk_options[CONF_DOMAINS]
hk_options = self.hk_options
domains = hk_options[CONF_DOMAINS]
entity_filter: EntityFilterDict
if user_input is not None:
entities = cv.ensure_list(user_input[CONF_ENTITIES])
entity_filter = _async_build_entites_filter(domains, entities)
entity_filter = _async_build_entities_filter(domains, entities)
self.included_cameras = _async_cameras_from_entities(entities)
self.hk_options[CONF_FILTER] = entity_filter
hk_options[CONF_FILTER] = entity_filter
if self.included_cameras:
return await self.async_step_cameras()
return await self.async_step_advanced()
entity_filter = self.hk_options.get(CONF_FILTER, {})
entity_filter = hk_options.get(CONF_FILTER, {})
entities = entity_filter.get(CONF_INCLUDE_ENTITIES, [])
all_supported_entities = _async_get_matching_entities(
self.hass, domains, include_entity_category=True, include_hidden=True
@ -494,24 +510,21 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
"""Choose entities to include from the domain on the bridge."""
domains = self.hk_options[CONF_DOMAINS]
hk_options = self.hk_options
domains = hk_options[CONF_DOMAINS]
if user_input is not None:
entities = cv.ensure_list(user_input[CONF_ENTITIES])
entity_filter = _async_build_entites_filter(domains, entities)
self.included_cameras = _async_cameras_from_entities(entities)
self.hk_options[CONF_FILTER] = entity_filter
hk_options[CONF_FILTER] = _async_build_entities_filter(domains, entities)
if self.included_cameras:
return await self.async_step_cameras()
return await self.async_step_advanced()
entity_filter = self.hk_options.get(CONF_FILTER, {})
entity_filter: EntityFilterDict = hk_options.get(CONF_FILTER, {})
entities = entity_filter.get(CONF_INCLUDE_ENTITIES, [])
all_supported_entities = _async_get_matching_entities(
self.hass, domains, include_entity_category=True, include_hidden=True
)
if not entities:
entities = entity_filter.get(CONF_EXCLUDE_ENTITIES, [])
# Strip out entities that no longer exist to prevent error in the UI
default_value = [
entity_id for entity_id in entities if entity_id in all_supported_entities
@ -535,15 +548,13 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
"""Choose entities to exclude from the domain on the bridge."""
domains = self.hk_options[CONF_DOMAINS]
hk_options = self.hk_options
domains = hk_options[CONF_DOMAINS]
if user_input is not None:
entity_filter = deepcopy(_EMPTY_ENTITY_FILTER)
entities = cv.ensure_list(user_input[CONF_ENTITIES])
entity_filter[CONF_INCLUDE_DOMAINS] = domains
entity_filter[CONF_EXCLUDE_ENTITIES] = entities
self.included_cameras = {}
if CAMERA_DOMAIN in entity_filter[CONF_INCLUDE_DOMAINS]:
entities = cv.ensure_list(user_input[CONF_ENTITIES])
if CAMERA_DOMAIN in domains:
camera_entities = _async_get_matching_entities(
self.hass, [CAMERA_DOMAIN]
)
@ -552,7 +563,9 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
for entity_id in camera_entities
if entity_id not in entities
}
self.hk_options[CONF_FILTER] = entity_filter
hk_options[CONF_FILTER] = _make_entity_filter(
include_domains=domains, exclude_entities=entities
)
if self.included_cameras:
return await self.async_step_cameras()
return await self.async_step_advanced()
@ -600,14 +613,13 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
self.hk_options = deepcopy(dict(self.config_entry.options))
homekit_mode = self.hk_options.get(CONF_HOMEKIT_MODE, DEFAULT_HOMEKIT_MODE)
entity_filter = self.hk_options.get(CONF_FILTER, {})
entity_filter: EntityFilterDict = self.hk_options.get(CONF_FILTER, {})
include_exclude_mode = MODE_INCLUDE
entities = entity_filter.get(CONF_INCLUDE_ENTITIES, [])
if homekit_mode != HOMEKIT_MODE_ACCESSORY:
include_exclude_mode = MODE_INCLUDE if entities else MODE_EXCLUDE
domains = entity_filter.get(CONF_INCLUDE_DOMAINS, [])
include_entities = entity_filter.get(CONF_INCLUDE_ENTITIES)
if include_entities:
if include_entities := entity_filter.get(CONF_INCLUDE_ENTITIES):
domains.extend(_domains_set_from_entities(include_entities))
name_to_type_map = await _async_name_to_type_map(self.hass)
return self.async_show_form(
@ -708,7 +720,7 @@ def _async_get_entity_ids_for_accessory_mode(
def _async_entity_ids_with_accessory_mode(hass: HomeAssistant) -> set[str]:
"""Return a set of entity ids that have config entries in accessory mode."""
entity_ids = set()
entity_ids: set[str] = set()
current_entries = hass.config_entries.async_entries(DOMAIN)
for entry in current_entries:

24
tests/components/homekit/test_config_flow.py
View file

@ -889,7 +889,7 @@ async def test_options_flow_include_mode_with_cameras(
"filter": {
"exclude_domains": [],
"exclude_entities": [],
"include_domains": ["fan", "vacuum", "climate"],
"include_domains": ["climate", "fan", "vacuum"],
"include_entities": ["camera.native_h264", "camera.transcode_h264"],
},
"entity_config": {"camera.native_h264": {"video_codec": "copy"}},
@ -904,15 +904,15 @@ async def test_options_flow_include_mode_with_cameras(
assert result["type"] == data_entry_flow.FlowResultType.FORM
assert result["step_id"] == "init"
assert result["data_schema"]({}) == {
"domains": ["fan", "vacuum", "climate", "camera"],
"domains": ["climate", "fan", "vacuum", "camera"],
"mode": "bridge",
"include_exclude_mode": "include",
}
schema = result["data_schema"].schema
assert _get_schema_default(schema, "domains") == [
"climate",
"fan",
"vacuum",
"climate",
"camera",
]
assert _get_schema_default(schema, "mode") == "bridge"
@ -921,7 +921,7 @@ async def test_options_flow_include_mode_with_cameras(
result = await hass.config_entries.options.async_configure(
result["flow_id"],
user_input={
"domains": ["fan", "vacuum", "climate", "camera"],
"domains": ["climate", "fan", "vacuum", "camera"],
"include_exclude_mode": "exclude",
},
)
@ -959,11 +959,11 @@ async def test_options_flow_include_mode_with_cameras(
assert result3["type"] == data_entry_flow.FlowResultType.CREATE_ENTRY
assert config_entry.options == {
"entity_config": {"camera.native_h264": {}},
"entity_config": {},
"filter": {
"exclude_domains": [],
"exclude_entities": ["climate.old", "camera.excluded"],
"include_domains": ["fan", "vacuum", "climate", "camera"],
"include_domains": ["climate", "fan", "vacuum", "camera"],
"include_entities": [],
},
"mode": "bridge",
@ -1025,7 +1025,7 @@ async def test_options_flow_with_camera_audio(
"filter": {
"exclude_domains": [],
"exclude_entities": [],
"include_domains": ["fan", "vacuum", "climate"],
"include_domains": ["climate", "fan", "vacuum"],
"include_entities": ["camera.audio", "camera.no_audio"],
},
"entity_config": {"camera.audio": {"support_audio": True}},
@ -1040,15 +1040,15 @@ async def test_options_flow_with_camera_audio(
assert result["type"] == data_entry_flow.FlowResultType.FORM
assert result["step_id"] == "init"
assert result["data_schema"]({}) == {
"domains": ["fan", "vacuum", "climate", "camera"],
"domains": ["climate", "fan", "vacuum", "camera"],
"mode": "bridge",
"include_exclude_mode": "include",
}
schema = result["data_schema"].schema
assert _get_schema_default(schema, "domains") == [
"climate",
"fan",
"vacuum",
"climate",
"camera",
]
assert _get_schema_default(schema, "mode") == "bridge"
@ -1058,7 +1058,7 @@ async def test_options_flow_with_camera_audio(
result["flow_id"],
user_input={
"include_exclude_mode": "exclude",
"domains": ["fan", "vacuum", "climate", "camera"],
"domains": ["climate", "fan", "vacuum", "camera"],
},
)
@ -1095,11 +1095,11 @@ async def test_options_flow_with_camera_audio(
assert result3["type"] == data_entry_flow.FlowResultType.CREATE_ENTRY
assert config_entry.options == {
"entity_config": {"camera.audio": {}},
"entity_config": {},
"filter": {
"exclude_domains": [],
"exclude_entities": ["climate.old", "camera.excluded"],
"include_domains": ["fan", "vacuum", "climate", "camera"],
"include_domains": ["climate", "fan", "vacuum", "camera"],
"include_entities": [],
},
"mode": "bridge",