async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
"""Set up Utility Meter from a config entry."""
entity_registry = er.async_get(hass)
hass.data[DATA_UTILITY][entry.entry_id] = {}
hass.data[DATA_UTILITY][entry.entry_id][DATA_TARIFF_SENSORS] = []
try:
er.async_validate_entity_id(entity_registry, entry.options[CONF_SOURCE_SENSOR])
except vol.Invalid:
# The entity is identified by an unknown entity registry ID
_LOGGER.error(
"Failed to setup utility_meter for unknown entity %s",
entry.options[CONF_SOURCE_SENSOR],
)
return False
if not entry.options.get(CONF_TARIFFS):
# Only a single meter sensor is required
hass.data[DATA_UTILITY][entry.entry_id][CONF_TARIFF_ENTITY] = None
await hass.config_entries.async_forward_entry_setups(entry, (Platform.SENSOR,))
else:
# Create tariff selection + one meter sensor for each tariff
entity_entry = entity_registry.async_get_or_create(
Platform.SELECT, DOMAIN, entry.entry_id, suggested_object_id=entry.title
)
hass.data[DATA_UTILITY][entry.entry_id][
CONF_TARIFF_ENTITY
] = entity_entry.entity_id
await hass.config_entries.async_forward_entry_setups(
entry, (Platform.SELECT, Platform.SENSOR)
)
entry.async_on_unload(entry.add_update_listener(config_entry_update_listener))
return True
async def async_setup_entry(
hass: HomeAssistant,
config_entry: ConfigEntry,
async_add_entities: AddEntitiesCallback,
) -> None:
"""Initialize Integration - Riemann sum integral config entry."""
registry = er.async_get(hass)
# Validate + resolve entity registry id to entity_id
source_entity_id = er.async_validate_entity_id(
registry, config_entry.options[CONF_SOURCE_SENSOR])
unit_prefix = config_entry.options[CONF_UNIT_PREFIX]
if unit_prefix == "none":
unit_prefix = None
integral = IntegrationSensor(
integration_method=config_entry.options[CONF_METHOD],
name=config_entry.title,
round_digits=int(config_entry.options[CONF_ROUND_DIGITS]),
source_entity=source_entity_id,
unique_id=config_entry.entry_id,
unit_prefix=unit_prefix,
unit_time=config_entry.options[CONF_UNIT_TIME],
)
async_add_entities([integral])
async def async_setup_entry(
hass: HomeAssistant,
config_entry: ConfigEntry,
async_add_entities: AddEntitiesCallback,
) -> None:
"""Initialize Derivative config entry."""
registry = er.async_get(hass)
# Validate + resolve entity registry id to entity_id
source_entity_id = er.async_validate_entity_id(
registry, config_entry.options[CONF_SOURCE])
unit_prefix = config_entry.options[CONF_UNIT_PREFIX]
if unit_prefix == "none":
unit_prefix = None
derivative_sensor = DerivativeSensor(
name=config_entry.title,
round_digits=int(config_entry.options[CONF_ROUND_DIGITS]),
source_entity=source_entity_id,
time_window=cv.time_period_dict(
config_entry.options[CONF_TIME_WINDOW]),
unique_id=config_entry.entry_id,
unit_of_measurement=None,
unit_prefix=unit_prefix,
unit_time=config_entry.options[CONF_UNIT_TIME],
)
async_add_entities([derivative_sensor])
async def async_remove_entry(hass: HomeAssistant, entry: ConfigEntry) -> None:
"""Unload a config entry."""
# Unhide the wrapped entry if registered
registry = er.async_get(hass)
try:
entity_id = er.async_validate_entity_id(registry, entry.options[CONF_ENTITY_ID])
except vol.Invalid:
# The source entity has been removed from the entity registry
return
if not (entity_entry := registry.async_get(entity_id)):
return
async def async_setup_entry(
hass: HomeAssistant,
config_entry: ConfigEntry,
async_add_entities: AddEntitiesCallback,
) -> None:
"""Initialize NEW_NAME config entry."""
registry = er.async_get(hass)
# Validate + resolve entity registry id to entity_id
entity_id = er.async_validate_entity_id(
registry, config_entry.options[CONF_ENTITY_ID])
# TODO Optionally validate config entry options before creating entity
name = config_entry.title
unique_id = config_entry.entry_id
async_add_entities([NEW_DOMAINSensorEntity(unique_id, name, entity_id)])
async def async_setup_entry(
hass: HomeAssistant,
config_entry: ConfigEntry,
async_add_entities: AddEntitiesCallback,
) -> None:
"""Initialize Cover Switch config entry."""
registry = er.async_get(hass)
entity_id = er.async_validate_entity_id(
registry, config_entry.options[CONF_ENTITY_ID])
wrapped_switch = registry.async_get(entity_id)
device_id = wrapped_switch.device_id if wrapped_switch else None
async_add_entities([
CoverSwitch(
config_entry.title,
entity_id,
config_entry.entry_id,
device_id,
)
])
async def async_setup_entry(
hass: HomeAssistant,
config_entry: ConfigEntry,
async_add_entities: AddEntitiesCallback,
) -> None:
"""Initialize threshold config entry."""
registry = er.async_get(hass)
device_class = None
entity_id = er.async_validate_entity_id(
registry, config_entry.options[CONF_ENTITY_ID])
hysteresis = config_entry.options[CONF_HYSTERESIS]
lower = config_entry.options[CONF_LOWER]
name = config_entry.title
unique_id = config_entry.entry_id
upper = config_entry.options[CONF_UPPER]
async_add_entities([
ThresholdSensor(hass, entity_id, name, lower, upper, hysteresis,
device_class, unique_id)
])
async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
"""Set up a config entry."""
registry = er.async_get(hass)
device_registry = dr.async_get(hass)
try:
entity_id = er.async_validate_entity_id(registry, entry.options[CONF_ENTITY_ID])
except vol.Invalid:
# The entity is identified by an unknown entity registry ID
_LOGGER.error(
"Failed to setup switch_as_x for unknown entity %s",
entry.options[CONF_ENTITY_ID],
)
return False
async def async_registry_updated(event: Event) -> None:
"""Handle entity registry update."""
data = event.data
if data["action"] == "remove":
await hass.config_entries.async_remove(entry.entry_id)
if data["action"] != "update":
return
if "entity_id" in data["changes"]:
# Entity_id changed, reload the config entry
await hass.config_entries.async_reload(entry.entry_id)
if device_id and "device_id" in data["changes"]:
# If the tracked switch is no longer in the device, remove our config entry
# from the device
if (
not (entity_entry := registry.async_get(data[CONF_ENTITY_ID]))
or not device_registry.async_get(device_id)
or entity_entry.device_id == device_id
):
# No need to do any cleanup
return
device_registry.async_update_device(
device_id, remove_config_entry_id=entry.entry_id
)
