async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
"""Set up configured zones as well as Home Assistant zone if necessary."""
component = entity_component.EntityComponent(_LOGGER, DOMAIN, hass)
id_manager = collection.IDManager()
yaml_collection = collection.IDLessCollection(
logging.getLogger(f"{__name__}.yaml_collection"), id_manager)
collection.sync_entity_lifecycle(hass, DOMAIN, DOMAIN, component,
yaml_collection, Zone.from_yaml)
storage_collection = ZoneStorageCollection(
storage.Store(hass, STORAGE_VERSION, STORAGE_KEY),
logging.getLogger(f"{__name__}.storage_collection"),
id_manager,
)
collection.sync_entity_lifecycle(hass, DOMAIN, DOMAIN, component,
storage_collection, Zone)
if config[DOMAIN]:
# AIS dom config can be empty
if config[DOMAIN] != [{}]:
await yaml_collection.async_load(config[DOMAIN])
await storage_collection.async_load()
collection.StorageCollectionWebsocket(storage_collection, DOMAIN, DOMAIN,
CREATE_FIELDS,
UPDATE_FIELDS).async_setup(hass)
async def reload_service_handler(service_call: ServiceCall) -> None:
"""Remove all zones and load new ones from config."""
conf = await component.async_prepare_reload(skip_reset=True)
if conf is None:
return
await yaml_collection.async_load(conf[DOMAIN])
service.async_register_admin_service(
hass,
DOMAIN,
SERVICE_RELOAD,
reload_service_handler,
schema=RELOAD_SERVICE_SCHEMA,
)
if component.get_entity("zone.home"):
return True
home_zone = Zone(_home_conf(hass))
home_zone.entity_id = ENTITY_ID_HOME
await component.async_add_entities([home_zone])
async def core_config_updated(_: Event) -> None:
"""Handle core config updated."""
await home_zone.async_update_config(_home_conf(hass))
hass.bus.async_listen(EVENT_CORE_CONFIG_UPDATE, core_config_updated)
hass.data[DOMAIN] = storage_collection
return True
async def async_setup(hass: HomeAssistantType, config: ConfigType) -> bool:
"""Set up an input boolean."""
component = EntityComponent(_LOGGER, DOMAIN, hass)
id_manager = collection.IDManager()
yaml_collection = collection.YamlCollection(
logging.getLogger(f"{__name__}.yaml_collection"), id_manager
)
collection.attach_entity_component_collection(
component, yaml_collection, lambda conf: InputBoolean(conf, from_yaml=True)
)
storage_collection = InputBooleanStorageCollection(
Store(hass, STORAGE_VERSION, STORAGE_KEY),
logging.getLogger(f"{__name__}_storage_collection"),
id_manager,
)
collection.attach_entity_component_collection(
component, storage_collection, InputBoolean
)
await yaml_collection.async_load(
[{CONF_ID: id_, **(conf or {})} for id_, conf in config.get(DOMAIN, {}).items()]
)
await storage_collection.async_load()
collection.StorageCollectionWebsocket(
storage_collection, DOMAIN, DOMAIN, CREATE_FIELDS, UPDATE_FIELDS
).async_setup(hass)
collection.attach_entity_registry_cleaner(hass, DOMAIN, DOMAIN, yaml_collection)
collection.attach_entity_registry_cleaner(hass, DOMAIN, DOMAIN, storage_collection)
async def reload_service_handler(service_call: ServiceCallType) -> None:
"""Remove all input booleans and load new ones from config."""
conf = await component.async_prepare_reload(skip_reset=True)
if conf is None:
return
await yaml_collection.async_load(
[
{CONF_ID: id_, **(conf or {})}
for id_, conf in conf.get(DOMAIN, {}).items()
]
)
homeassistant.helpers.service.async_register_admin_service(
hass,
DOMAIN,
SERVICE_RELOAD,
reload_service_handler,
schema=RELOAD_SERVICE_SCHEMA,
)
component.async_register_entity_service(SERVICE_TURN_ON, {}, "async_turn_on")
component.async_register_entity_service(SERVICE_TURN_OFF, {}, "async_turn_off")
component.async_register_entity_service(SERVICE_TOGGLE, {}, "async_toggle")
return True
async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
"""Set up an input boolean."""
component = EntityComponent(_LOGGER, DOMAIN, hass)
# Process integration platforms right away since
# we will create entities before firing EVENT_COMPONENT_LOADED
await async_process_integration_platform_for_component(hass, DOMAIN)
id_manager = collection.IDManager()
yaml_collection = collection.YamlCollection(
logging.getLogger(f"{__name__}.yaml_collection"), id_manager)
collection.sync_entity_lifecycle(hass, DOMAIN, DOMAIN, component,
yaml_collection, InputBoolean.from_yaml)
storage_collection = InputBooleanStorageCollection(
Store(hass, STORAGE_VERSION, STORAGE_KEY),
logging.getLogger(f"{__name__}.storage_collection"),
id_manager,
)
collection.sync_entity_lifecycle(hass, DOMAIN, DOMAIN, component,
storage_collection, InputBoolean)
await yaml_collection.async_load([{
CONF_ID: id_,
**(conf or {})
} for id_, conf in config.get(DOMAIN, {}).items()])
await storage_collection.async_load()
collection.StorageCollectionWebsocket(storage_collection, DOMAIN, DOMAIN,
CREATE_FIELDS,
UPDATE_FIELDS).async_setup(hass)
async def reload_service_handler(service_call: ServiceCall) -> None:
"""Remove all input booleans and load new ones from config."""
conf = await component.async_prepare_reload(skip_reset=True)
if conf is None:
return
await yaml_collection.async_load([{
CONF_ID: id_,
**(conf or {})
} for id_, conf in conf.get(DOMAIN, {}).items()])
homeassistant.helpers.service.async_register_admin_service(
hass,
DOMAIN,
SERVICE_RELOAD,
reload_service_handler,
schema=RELOAD_SERVICE_SCHEMA,
)
component.async_register_entity_service(SERVICE_TURN_ON, {},
"async_turn_on")
component.async_register_entity_service(SERVICE_TURN_OFF, {},
"async_turn_off")
component.async_register_entity_service(SERVICE_TOGGLE, {}, "async_toggle")
return True
async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
"""Set up an input slider."""
component = EntityComponent(_LOGGER, DOMAIN, hass)
id_manager = collection.IDManager()
yaml_collection = collection.YamlCollection(
logging.getLogger(f"{__name__}.yaml_collection"), id_manager)
collection.sync_entity_lifecycle(hass, DOMAIN, DOMAIN, component,
yaml_collection, InputNumber.from_yaml)
storage_collection = NumberStorageCollection(
Store(hass, STORAGE_VERSION, STORAGE_KEY),
logging.getLogger(f"{__name__}.storage_collection"),
id_manager,
)
collection.sync_entity_lifecycle(hass, DOMAIN, DOMAIN, component,
storage_collection, InputNumber)
await yaml_collection.async_load([{
CONF_ID: id_,
**(conf or {})
} for id_, conf in config.get(DOMAIN, {}).items()])
await storage_collection.async_load()
collection.StorageCollectionWebsocket(storage_collection, DOMAIN, DOMAIN,
CREATE_FIELDS,
UPDATE_FIELDS).async_setup(hass)
async def reload_service_handler(service_call: ServiceCall) -> None:
"""Reload yaml entities."""
conf = await component.async_prepare_reload(skip_reset=True)
if conf is None:
conf = {DOMAIN: {}}
await yaml_collection.async_load([{
CONF_ID: id_,
**conf
} for id_, conf in conf.get(DOMAIN, {}).items()])
homeassistant.helpers.service.async_register_admin_service(
hass,
DOMAIN,
SERVICE_RELOAD,
reload_service_handler,
schema=RELOAD_SERVICE_SCHEMA,
)
component.async_register_entity_service(
SERVICE_SET_VALUE,
{vol.Required(ATTR_VALUE): vol.Coerce(float)},
"async_set_value",
)
component.async_register_entity_service(SERVICE_INCREMENT, {},
"async_increment")
component.async_register_entity_service(SERVICE_DECREMENT, {},
"async_decrement")
return True
async def async_setup(hass: HomeAssistant, config: ConfigType):
"""Set up the person component."""
entity_component = EntityComponent(_LOGGER, DOMAIN, hass)
id_manager = collection.IDManager()
yaml_collection = collection.YamlCollection(
logging.getLogger(f"{__name__}.yaml_collection"), id_manager
)
storage_collection = PersonStorageCollection(
PersonStore(hass, STORAGE_VERSION, STORAGE_KEY),
logging.getLogger(f"{__name__}.storage_collection"),
id_manager,
yaml_collection,
)
collection.sync_entity_lifecycle(
hass, DOMAIN, DOMAIN, entity_component, yaml_collection, Person
)
collection.sync_entity_lifecycle(
hass, DOMAIN, DOMAIN, entity_component, storage_collection, Person.from_yaml
)
await yaml_collection.async_load(
await filter_yaml_data(hass, config.get(DOMAIN, []))
)
await storage_collection.async_load()
hass.data[DOMAIN] = (yaml_collection, storage_collection)
collection.StorageCollectionWebsocket(
storage_collection, DOMAIN, DOMAIN, CREATE_FIELDS, UPDATE_FIELDS
).async_setup(hass, create_list=False)
websocket_api.async_register_command(hass, ws_list_person)
async def _handle_user_removed(event: Event) -> None:
"""Handle a user being removed."""
user_id = event.data[ATTR_USER_ID]
for person in storage_collection.async_items():
if person[CONF_USER_ID] == user_id:
await storage_collection.async_update_item(
person[CONF_ID], {CONF_USER_ID: None}
)
hass.bus.async_listen(EVENT_USER_REMOVED, _handle_user_removed)
async def async_reload_yaml(call: ServiceCall):
"""Reload YAML."""
conf = await entity_component.async_prepare_reload(skip_reset=True)
if conf is None:
return
await yaml_collection.async_load(
await filter_yaml_data(hass, conf.get(DOMAIN, []))
)
service.async_register_admin_service(
hass, DOMAIN, SERVICE_RELOAD, async_reload_yaml
)
return True
async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
"""Set up an input select."""
component = EntityComponent(_LOGGER, DOMAIN, hass)
id_manager = collection.IDManager()
yaml_collection = collection.YamlCollection(
logging.getLogger(f"{__name__}.yaml_collection"), id_manager)
collection.sync_entity_lifecycle(hass, DOMAIN, DOMAIN, component,
yaml_collection, Timer.from_yaml)
storage_collection = TimerStorageCollection(
Store(hass, STORAGE_VERSION, STORAGE_KEY),
logging.getLogger(f"{__name__}.storage_collection"),
id_manager,
)
collection.sync_entity_lifecycle(hass, DOMAIN, DOMAIN, component,
storage_collection, Timer)
await yaml_collection.async_load([{
CONF_ID: id_,
**cfg
} for id_, cfg in config.get(DOMAIN, {}).items()])
await storage_collection.async_load()
collection.StorageCollectionWebsocket(storage_collection, DOMAIN, DOMAIN,
CREATE_FIELDS,
UPDATE_FIELDS).async_setup(hass)
async def reload_service_handler(service_call: ServiceCallType) -> None:
"""Reload yaml entities."""
conf = await component.async_prepare_reload(skip_reset=True)
if conf is None:
conf = {DOMAIN: {}}
await yaml_collection.async_load([{
CONF_ID: id_,
**cfg
} for id_, cfg in conf.get(DOMAIN, {}).items()])
homeassistant.helpers.service.async_register_admin_service(
hass,
DOMAIN,
SERVICE_RELOAD,
reload_service_handler,
schema=RELOAD_SERVICE_SCHEMA,
)
component.async_register_entity_service(
SERVICE_START,
{
vol.Optional(ATTR_DURATION, default=DEFAULT_DURATION):
cv.time_period
},
"async_start",
)
component.async_register_entity_service(SERVICE_PAUSE, {}, "async_pause")
component.async_register_entity_service(SERVICE_CANCEL, {}, "async_cancel")
component.async_register_entity_service(SERVICE_FINISH, {}, "async_finish")
return True
async def async_setup(hass: HomeAssistantType, config: ConfigType) -> bool:
"""Set up an input text."""
component = hass.data[DOMAIN] = EntityComponent(_LOGGER, DOMAIN, hass)
id_manager = collection.IDManager()
yaml_collection = collection.YamlCollection(
logging.getLogger(f"{__name__}.yaml_collection"), id_manager)
collection.attach_entity_component_collection(component, yaml_collection,
InputText.from_yaml)
storage_collection = InputTextStorageCollection(
Store(hass, STORAGE_VERSION, STORAGE_KEY),
logging.getLogger(f"{__name__}.storage_collection"),
id_manager,
)
collection.attach_entity_component_collection(component,
storage_collection,
InputText)
await yaml_collection.async_load([{
CONF_ID: id_,
**(conf or {})
} for id_, conf in config.get(DOMAIN, {}).items()])
await storage_collection.async_load()
collection.StorageCollectionWebsocket(storage_collection, DOMAIN, DOMAIN,
CREATE_FIELDS,
UPDATE_FIELDS).async_setup(hass)
collection.attach_entity_registry_cleaner(hass, DOMAIN, DOMAIN,
yaml_collection)
collection.attach_entity_registry_cleaner(hass, DOMAIN, DOMAIN,
storage_collection)
async def reload_service_handler(service_call: ServiceCallType) -> None:
"""Reload yaml entities."""
conf = await component.async_prepare_reload(skip_reset=True)
if conf is None:
conf = {DOMAIN: {}}
await yaml_collection.async_load([{
CONF_ID: id_,
**(cfg or {})
} for id_, cfg in conf.get(DOMAIN, {}).items()])
homeassistant.helpers.service.async_register_admin_service(
hass,
DOMAIN,
SERVICE_RELOAD,
reload_service_handler,
schema=RELOAD_SERVICE_SCHEMA,
)
component.async_register_entity_service(
SERVICE_SET_VALUE, {vol.Required(ATTR_VALUE): cv.string},
"async_set_value")
return True
def storage_collection(hass):
"""Return an empty storage collection."""
id_manager = collection.IDManager()
return person.PersonStorageCollection(
person.PersonStore(hass, person.STORAGE_VERSION, person.STORAGE_KEY),
logging.getLogger(f"{person.__name__}.storage_collection"),
id_manager,
collection.YamlCollection(
logging.getLogger(f"{person.__name__}.yaml_collection"),
id_manager),
)
def test_id_manager():
"""Test the ID manager."""
id_manager = collection.IDManager()
assert not id_manager.has_id("some_id")
data = {}
id_manager.add_collection(data)
assert not id_manager.has_id("some_id")
data["some_id"] = 1
assert id_manager.has_id("some_id")
assert id_manager.generate_id("some_id") == "some_id_2"
assert id_manager.generate_id("bla") == "bla"
async def async_setup(hass: HomeAssistantType, config: ConfigType) -> bool:
"""Set up the counters."""
component = EntityComponent(_LOGGER, DOMAIN, hass)
id_manager = collection.IDManager()
yaml_collection = collection.YamlCollection(
logging.getLogger(f"{__name__}.yaml_collection"), id_manager)
collection.attach_entity_component_collection(component, yaml_collection,
Counter.from_yaml)
storage_collection = CounterStorageCollection(
Store(hass, STORAGE_VERSION, STORAGE_KEY),
logging.getLogger(f"{__name__}.storage_collection"),
id_manager,
)
collection.attach_entity_component_collection(component,
storage_collection, Counter)
await yaml_collection.async_load([{
CONF_ID: id_,
**(conf or {})
} for id_, conf in config.get(DOMAIN, {}).items()])
await storage_collection.async_load()
collection.StorageCollectionWebsocket(storage_collection, DOMAIN, DOMAIN,
CREATE_FIELDS,
UPDATE_FIELDS).async_setup(hass)
collection.attach_entity_registry_cleaner(hass, DOMAIN, DOMAIN,
yaml_collection)
collection.attach_entity_registry_cleaner(hass, DOMAIN, DOMAIN,
storage_collection)
component.async_register_entity_service(SERVICE_INCREMENT, {},
"async_increment")
component.async_register_entity_service(SERVICE_DECREMENT, {},
"async_decrement")
component.async_register_entity_service(SERVICE_RESET, {}, "async_reset")
component.async_register_entity_service(
SERVICE_CONFIGURE,
{
vol.Optional(ATTR_MINIMUM): vol.Any(None, vol.Coerce(int)),
vol.Optional(ATTR_MAXIMUM): vol.Any(None, vol.Coerce(int)),
vol.Optional(ATTR_STEP): cv.positive_int,
vol.Optional(ATTR_INITIAL): cv.positive_int,
vol.Optional(VALUE): cv.positive_int,
},
"async_configure",
)
return True
async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
"""Set up an input button."""
component = EntityComponent(_LOGGER, DOMAIN, hass)
id_manager = collection.IDManager()
yaml_collection = collection.YamlCollection(
logging.getLogger(f"{__name__}.yaml_collection"), id_manager)
collection.sync_entity_lifecycle(hass, DOMAIN, DOMAIN, component,
yaml_collection, InputButton.from_yaml)
storage_collection = InputButtonStorageCollection(
Store(hass, STORAGE_VERSION, STORAGE_KEY),
logging.getLogger(f"{__name__}.storage_collection"),
id_manager,
)
collection.sync_entity_lifecycle(hass, DOMAIN, DOMAIN, component,
storage_collection, InputButton)
await yaml_collection.async_load([{
CONF_ID: id_,
**(conf or {})
} for id_, conf in config.get(DOMAIN, {}).items()])
await storage_collection.async_load()
collection.StorageCollectionWebsocket(storage_collection, DOMAIN, DOMAIN,
CREATE_FIELDS,
UPDATE_FIELDS).async_setup(hass)
async def reload_service_handler(service_call: ServiceCall) -> None:
"""Remove all input buttons and load new ones from config."""
conf = await component.async_prepare_reload(skip_reset=True)
if conf is None:
return
await yaml_collection.async_load([{
CONF_ID: id_,
**(conf or {})
} for id_, conf in conf.get(DOMAIN, {}).items()])
homeassistant.helpers.service.async_register_admin_service(
hass,
DOMAIN,
SERVICE_RELOAD,
reload_service_handler,
schema=RELOAD_SERVICE_SCHEMA,
)
component.async_register_entity_service(SERVICE_PRESS, {},
"_async_press_action")
return True
async def test_yaml_collection_skipping_duplicate_ids():
"""Test YAML collection skipping duplicate IDs."""
id_manager = collection.IDManager()
id_manager.add_collection({"existing": True})
coll = collection.YamlCollection(LOGGER, id_manager)
changes = track_changes(coll)
await coll.async_load(
[{"id": "mock-1", "name": "Mock 1"}, {"id": "existing", "name": "Mock 2"}]
)
assert len(changes) == 1
assert changes[0] == (
collection.CHANGE_ADDED,
"mock-1",
{"id": "mock-1", "name": "Mock 1"},
)
async def test_yaml_collection():
"""Test a YAML collection."""
id_manager = collection.IDManager()
coll = collection.YamlCollection(LOGGER, id_manager)
changes = track_changes(coll)
await coll.async_load(
[{"id": "mock-1", "name": "Mock 1"}, {"id": "mock-2", "name": "Mock 2"}]
)
assert id_manager.has_id("mock-1")
assert id_manager.has_id("mock-2")
assert len(changes) == 2
assert changes[0] == (
collection.CHANGE_ADDED,
"mock-1",
{"id": "mock-1", "name": "Mock 1"},
)
assert changes[1] == (
collection.CHANGE_ADDED,
"mock-2",
{"id": "mock-2", "name": "Mock 2"},
)
# Test loading new data. Mock 1 is updated, 2 removed, 3 added.
await coll.async_load(
[{"id": "mock-1", "name": "Mock 1-updated"}, {"id": "mock-3", "name": "Mock 3"}]
)
assert len(changes) == 5
assert changes[2] == (
collection.CHANGE_UPDATED,
"mock-1",
{"id": "mock-1", "name": "Mock 1-updated"},
)
assert changes[3] == (
collection.CHANGE_ADDED,
"mock-3",
{"id": "mock-3", "name": "Mock 3"},
)
assert changes[4] == (
collection.CHANGE_REMOVED,
"mock-2",
{"id": "mock-2", "name": "Mock 2"},
)
async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
"""Set up Application Credentials."""
hass.data[DOMAIN] = {}
id_manager = collection.IDManager()
storage_collection = ApplicationCredentialsStorageCollection(
Store(hass, STORAGE_VERSION, STORAGE_KEY),
logging.getLogger(f"{__name__}.storage_collection"),
id_manager,
)
await storage_collection.async_load()
hass.data[DOMAIN][DATA_STORAGE] = storage_collection
collection.StorageCollectionWebsocket(storage_collection, DOMAIN, DOMAIN,
CREATE_FIELDS,
UPDATE_FIELDS).async_setup(hass)
websocket_api.async_register_command(hass, handle_integration_list)
config_entry_oauth2_flow.async_add_implementation_provider(
hass, DOMAIN, _async_provide_implementation)
return True
async def async_setup(hass: HomeAssistantType, config: ConfigType) -> bool:
"""Set up an input datetime."""
component = EntityComponent(_LOGGER, DOMAIN, hass)
id_manager = collection.IDManager()
yaml_collection = collection.YamlCollection(
logging.getLogger(f"{__name__}.yaml_collection"), id_manager)
collection.sync_entity_lifecycle(hass, DOMAIN, DOMAIN, component,
yaml_collection, InputDatetime.from_yaml)
storage_collection = DateTimeStorageCollection(
Store(hass, STORAGE_VERSION, STORAGE_KEY),
logging.getLogger(f"{__name__}.storage_collection"),
id_manager,
)
collection.sync_entity_lifecycle(hass, DOMAIN, DOMAIN, component,
storage_collection, InputDatetime)
await yaml_collection.async_load([{
CONF_ID: id_,
**cfg
} for id_, cfg in config.get(DOMAIN, {}).items()])
await storage_collection.async_load()
collection.StorageCollectionWebsocket(storage_collection, DOMAIN, DOMAIN,
CREATE_FIELDS,
UPDATE_FIELDS).async_setup(hass)
async def reload_service_handler(service_call: ServiceCallType) -> None:
"""Reload yaml entities."""
conf = await component.async_prepare_reload(skip_reset=True)
if conf is None:
conf = {DOMAIN: {}}
await yaml_collection.async_load([{
CONF_ID: id_,
**cfg
} for id_, cfg in conf.get(DOMAIN, {}).items()])
homeassistant.helpers.service.async_register_admin_service(
hass,
DOMAIN,
SERVICE_RELOAD,
reload_service_handler,
schema=RELOAD_SERVICE_SCHEMA,
)
component.async_register_entity_service(
"set_datetime",
vol.All(
vol.Schema(
{
vol.Optional(ATTR_DATE): cv.date,
vol.Optional(ATTR_TIME): cv.time,
vol.Optional(ATTR_DATETIME): cv.datetime,
vol.Optional(ATTR_TIMESTAMP): vol.Coerce(float),
},
extra=vol.ALLOW_EXTRA,
),
cv.has_at_least_one_key(ATTR_DATE, ATTR_TIME, ATTR_DATETIME,
ATTR_TIMESTAMP),
validate_set_datetime_attrs,
),
"async_set_datetime",
)
return True
async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
"""Set up an input select."""
component = EntityComponent(_LOGGER, DOMAIN, hass)
# Process integration platforms right away since
# we will create entities before firing EVENT_COMPONENT_LOADED
await async_process_integration_platform_for_component(hass, DOMAIN)
id_manager = collection.IDManager()
yaml_collection = collection.YamlCollection(
logging.getLogger(f"{__name__}.yaml_collection"), id_manager)
collection.sync_entity_lifecycle(hass, DOMAIN, DOMAIN, component,
yaml_collection, InputSelect.from_yaml)
storage_collection = InputSelectStorageCollection(
InputSelectStore(hass,
STORAGE_VERSION,
STORAGE_KEY,
minor_version=STORAGE_VERSION_MINOR),
logging.getLogger(f"{__name__}.storage_collection"),
id_manager,
)
collection.sync_entity_lifecycle(hass, DOMAIN, DOMAIN, component,
storage_collection, InputSelect)
await yaml_collection.async_load([{
CONF_ID: id_,
**cfg
} for id_, cfg in config.get(DOMAIN, {}).items()])
await storage_collection.async_load()
collection.StorageCollectionWebsocket(storage_collection, DOMAIN, DOMAIN,
CREATE_FIELDS,
UPDATE_FIELDS).async_setup(hass)
async def reload_service_handler(service_call: ServiceCall) -> None:
"""Reload yaml entities."""
conf = await component.async_prepare_reload(skip_reset=True)
if conf is None:
conf = {DOMAIN: {}}
await yaml_collection.async_load([{
CONF_ID: id_,
**cfg
} for id_, cfg in conf.get(DOMAIN, {}).items()])
homeassistant.helpers.service.async_register_admin_service(
hass,
DOMAIN,
SERVICE_RELOAD,
reload_service_handler,
schema=RELOAD_SERVICE_SCHEMA,
)
component.async_register_entity_service(
SERVICE_SELECT_OPTION,
{vol.Required(ATTR_OPTION): cv.string},
"async_select_option",
)
component.async_register_entity_service(
SERVICE_SELECT_NEXT,
{vol.Optional(ATTR_CYCLE, default=True): bool},
"async_next",
)
component.async_register_entity_service(
SERVICE_SELECT_PREVIOUS,
{vol.Optional(ATTR_CYCLE, default=True): bool},
"async_previous",
)
component.async_register_entity_service(
SERVICE_SELECT_FIRST,
{},
callback(lambda entity, call: entity.async_select_index(0)),
)
component.async_register_entity_service(
SERVICE_SELECT_LAST,
{},
callback(lambda entity, call: entity.async_select_index(-1)),
)
component.async_register_entity_service(
SERVICE_SET_OPTIONS,
{
vol.Required(ATTR_OPTIONS):
vol.All(cv.ensure_list, vol.Length(min=1), [cv.string])
},
"async_set_options",
)
return True
async def async_setup(hass: HomeAssistantType, config: ConfigType) -> bool:
"""Set up an input datetime."""
component = EntityComponent(_LOGGER, DOMAIN, hass)
id_manager = collection.IDManager()
yaml_collection = collection.YamlCollection(
logging.getLogger(f"{__name__}.yaml_collection"), id_manager)
collection.attach_entity_component_collection(component, yaml_collection,
InputDatetime.from_yaml)
storage_collection = DateTimeStorageCollection(
Store(hass, STORAGE_VERSION, STORAGE_KEY),
logging.getLogger(f"{__name__}.storage_collection"),
id_manager,
)
collection.attach_entity_component_collection(component,
storage_collection,
InputDatetime)
await yaml_collection.async_load([{
CONF_ID: id_,
**cfg
} for id_, cfg in config.get(DOMAIN, {}).items()])
await storage_collection.async_load()
collection.StorageCollectionWebsocket(storage_collection, DOMAIN, DOMAIN,
CREATE_FIELDS,
UPDATE_FIELDS).async_setup(hass)
collection.attach_entity_registry_cleaner(hass, DOMAIN, DOMAIN,
yaml_collection)
collection.attach_entity_registry_cleaner(hass, DOMAIN, DOMAIN,
storage_collection)
async def reload_service_handler(service_call: ServiceCallType) -> None:
"""Reload yaml entities."""
conf = await component.async_prepare_reload(skip_reset=True)
if conf is None:
conf = {DOMAIN: {}}
await yaml_collection.async_load([{
CONF_ID: id_,
**cfg
} for id_, cfg in conf.get(DOMAIN, {}).items()])
homeassistant.helpers.service.async_register_admin_service(
hass,
DOMAIN,
SERVICE_RELOAD,
reload_service_handler,
schema=RELOAD_SERVICE_SCHEMA,
)
async def async_set_datetime_service(entity, call):
"""Handle a call to the input datetime 'set datetime' service."""
time = call.data.get(ATTR_TIME)
date = call.data.get(ATTR_DATE)
dttm = call.data.get(ATTR_DATETIME)
if (dttm and (date or time) or entity.has_date and not (date or dttm)
or entity.has_time and not (time or dttm)):
_LOGGER.error(
"Invalid service data for %s input_datetime.set_datetime: %s",
entity.entity_id,
str(call.data),
)
return
if dttm:
date = dttm.date()
time = dttm.time()
entity.async_set_datetime(date, time)
component.async_register_entity_service(
SERVICE_SET_DATETIME,
{
vol.Optional(ATTR_DATE): cv.date,
vol.Optional(ATTR_TIME): cv.time,
vol.Optional(ATTR_DATETIME): cv.datetime,
},
async_set_datetime_service,
)
return True
async def async_setup(hass: HomeAssistantType, config: ConfigType) -> bool:
"""Set up an input select."""
component = hass.data[DOMAIN] = EntityComponent(_LOGGER, DOMAIN, hass)
id_manager = collection.IDManager()
yaml_collection = collection.YamlCollection(
logging.getLogger(f"{__name__}.yaml_collection"), id_manager)
collection.attach_entity_component_collection(component, yaml_collection,
InputSelect.from_yaml)
storage_collection = InputSelectStorageCollection(
Store(hass, STORAGE_VERSION, STORAGE_KEY),
logging.getLogger(f"{__name__}.storage_collection"),
id_manager,
)
collection.attach_entity_component_collection(component,
storage_collection,
InputSelect)
await yaml_collection.async_load([{
CONF_ID: id_,
**cfg
} for id_, cfg in config.get(DOMAIN, {}).items()])
await storage_collection.async_load()
collection.StorageCollectionWebsocket(storage_collection, DOMAIN, DOMAIN,
CREATE_FIELDS,
UPDATE_FIELDS).async_setup(hass)
collection.attach_entity_registry_cleaner(hass, DOMAIN, DOMAIN,
yaml_collection)
collection.attach_entity_registry_cleaner(hass, DOMAIN, DOMAIN,
storage_collection)
async def reload_service_handler(service_call: ServiceCallType) -> None:
"""Reload yaml entities."""
conf = await component.async_prepare_reload(skip_reset=True)
if conf is None:
conf = {DOMAIN: {}}
await yaml_collection.async_load([{
CONF_ID: id_,
**cfg
} for id_, cfg in conf.get(DOMAIN, {}).items()])
homeassistant.helpers.service.async_register_admin_service(
hass,
DOMAIN,
SERVICE_RELOAD,
reload_service_handler,
schema=RELOAD_SERVICE_SCHEMA,
)
component.async_register_entity_service(
SERVICE_SELECT_OPTION,
{vol.Required(ATTR_OPTION): cv.string},
"async_select_option",
)
component.async_register_entity_service(
SERVICE_SELECT_NEXT,
{},
callback(lambda entity, call: entity.async_offset_index(1)),
)
component.async_register_entity_service(
SERVICE_SELECT_PREVIOUS,
{},
callback(lambda entity, call: entity.async_offset_index(-1)),
)
component.async_register_entity_service(
SERVICE_SET_OPTIONS,
{
vol.Required(ATTR_OPTIONS):
vol.All(cv.ensure_list, vol.Length(min=1), [cv.string])
},
"async_set_options",
)
return True
async def async_setup(hass: HomeAssistant, config: Dict) -> bool:
"""Set up configured zones as well as Home Assistant zone if necessary."""
component = entity_component.EntityComponent(_LOGGER, DOMAIN, hass)
id_manager = collection.IDManager()
yaml_collection = collection.IDLessCollection(
logging.getLogger(f"{__name__}.yaml_collection"), id_manager
)
collection.attach_entity_component_collection(
component, yaml_collection, lambda conf: Zone(conf, False)
)
storage_collection = ZoneStorageCollection(
storage.Store(hass, STORAGE_VERSION, STORAGE_KEY),
logging.getLogger(f"{__name__}.storage_collection"),
id_manager,
)
collection.attach_entity_component_collection(
component, storage_collection, lambda conf: Zone(conf, True)
)
if config[DOMAIN]:
# AIS dom config can be empty
if config[DOMAIN] != [{}]:
await yaml_collection.async_load(config[DOMAIN])
await storage_collection.async_load()
collection.StorageCollectionWebsocket(
storage_collection, DOMAIN, DOMAIN, CREATE_FIELDS, UPDATE_FIELDS
).async_setup(hass)
async def _collection_changed(change_type: str, item_id: str, config: Dict) -> None:
"""Handle a collection change: clean up entity registry on removals."""
if change_type != collection.CHANGE_REMOVED:
return
ent_reg = await entity_registry.async_get_registry(hass)
ent_reg.async_remove(
cast(str, ent_reg.async_get_entity_id(DOMAIN, DOMAIN, item_id))
)
storage_collection.async_add_listener(_collection_changed)
async def reload_service_handler(service_call: ServiceCall) -> None:
"""Remove all zones and load new ones from config."""
conf = await component.async_prepare_reload(skip_reset=True)
if conf is None:
return
await yaml_collection.async_load(conf[DOMAIN])
service.async_register_admin_service(
hass,
DOMAIN,
SERVICE_RELOAD,
reload_service_handler,
schema=RELOAD_SERVICE_SCHEMA,
)
if component.get_entity("zone.home"):
return True
home_zone = Zone(
_home_conf(hass),
True,
)
home_zone.entity_id = ENTITY_ID_HOME
await component.async_add_entities([home_zone])
async def core_config_updated(_: Event) -> None:
"""Handle core config updated."""
await home_zone.async_update_config(_home_conf(hass))
hass.bus.async_listen(EVENT_CORE_CONFIG_UPDATE, core_config_updated)
hass.data[DOMAIN] = storage_collection
return True
async def test_storage_collection(hass):
"""Test storage collection."""
store = storage.Store(hass, 1, "test-data")
await store.async_save(
{
"items": [
{"id": "mock-1", "name": "Mock 1", "data": 1},
{"id": "mock-2", "name": "Mock 2", "data": 2},
]
}
)
id_manager = collection.IDManager()
coll = MockStorageCollection(store, LOGGER, id_manager)
changes = track_changes(coll)
await coll.async_load()
assert id_manager.has_id("mock-1")
assert id_manager.has_id("mock-2")
assert len(changes) == 2
assert changes[0] == (
collection.CHANGE_ADDED,
"mock-1",
{"id": "mock-1", "name": "Mock 1", "data": 1},
)
assert changes[1] == (
collection.CHANGE_ADDED,
"mock-2",
{"id": "mock-2", "name": "Mock 2", "data": 2},
)
item = await coll.async_create_item({"name": "Mock 3"})
assert item["id"] == "mock_3"
assert len(changes) == 3
assert changes[2] == (
collection.CHANGE_ADDED,
"mock_3",
{"id": "mock_3", "name": "Mock 3"},
)
updated_item = await coll.async_update_item("mock-2", {"name": "Mock 2 updated"})
assert id_manager.has_id("mock-2")
assert updated_item == {"id": "mock-2", "name": "Mock 2 updated", "data": 2}
assert len(changes) == 4
assert changes[3] == (collection.CHANGE_UPDATED, "mock-2", updated_item)
with pytest.raises(ValueError):
await coll.async_update_item("mock-2", {"id": "mock-2-updated"})
assert id_manager.has_id("mock-2")
assert not id_manager.has_id("mock-2-updated")
assert len(changes) == 4
await flush_store(store)
assert await storage.Store(hass, 1, "test-data").async_load() == {
"items": [
{"id": "mock-1", "name": "Mock 1", "data": 1},
{"id": "mock-2", "name": "Mock 2 updated", "data": 2},
{"id": "mock_3", "name": "Mock 3"},
]
}
async def async_setup(hass: HomeAssistantType, config: ConfigType) -> bool:
"""Set up an input datetime."""
component = EntityComponent(_LOGGER, DOMAIN, hass)
id_manager = collection.IDManager()
yaml_collection = collection.YamlCollection(
logging.getLogger(f"{__name__}.yaml_collection"), id_manager)
collection.attach_entity_component_collection(component, yaml_collection,
InputDatetime.from_yaml)
storage_collection = DateTimeStorageCollection(
Store(hass, STORAGE_VERSION, STORAGE_KEY),
logging.getLogger(f"{__name__}.storage_collection"),
id_manager,
)
collection.attach_entity_component_collection(component,
storage_collection,
InputDatetime)
await yaml_collection.async_load([{
CONF_ID: id_,
**cfg
} for id_, cfg in config.get(DOMAIN, {}).items()])
await storage_collection.async_load()
collection.StorageCollectionWebsocket(storage_collection, DOMAIN, DOMAIN,
CREATE_FIELDS,
UPDATE_FIELDS).async_setup(hass)
collection.attach_entity_registry_cleaner(hass, DOMAIN, DOMAIN,
yaml_collection)
collection.attach_entity_registry_cleaner(hass, DOMAIN, DOMAIN,
storage_collection)
async def reload_service_handler(service_call: ServiceCallType) -> None:
"""Reload yaml entities."""
conf = await component.async_prepare_reload(skip_reset=True)
if conf is None:
conf = {DOMAIN: {}}
await yaml_collection.async_load([{
CONF_ID: id_,
**cfg
} for id_, cfg in conf.get(DOMAIN, {}).items()])
homeassistant.helpers.service.async_register_admin_service(
hass,
DOMAIN,
SERVICE_RELOAD,
reload_service_handler,
schema=RELOAD_SERVICE_SCHEMA,
)
async def async_set_datetime_service(entity, call):
"""Handle a call to the input datetime 'set datetime' service."""
date = call.data.get(ATTR_DATE)
time = call.data.get(ATTR_TIME)
dttm = call.data.get(ATTR_DATETIME)
tmsp = call.data.get(ATTR_TIMESTAMP)
if tmsp:
dttm = dt_util.as_local(
dt_util.utc_from_timestamp(tmsp)).replace(tzinfo=None)
if dttm:
date = dttm.date()
time = dttm.time()
if not entity.has_date:
date = None
if not entity.has_time:
time = None
if not date and not time:
raise vol.Invalid("Nothing to set")
entity.async_set_datetime(date, time)
component.async_register_entity_service(SERVICE_SET_DATETIME,
SERVICE_SET_DATETIME_SCHEMA,
async_set_datetime_service)
return True
