async def async_setup_entry(
hass: core.HomeAssistant,
config_entry: config_entries.ConfigEntry,
async_add_entities,
):
_LOGGER.debug("setup switch...")
_LOGGER.debug(repr(config_entry.as_dict()))
config = config_entry.as_dict()["data"]
chargerName = config[CONF_NAME]
host = config[CONF_HOST]
chargerApi = GoeCharger(host)
entities = []
attribute = "allow_charging"
entities.append(
GoeChargerSwitch(
hass.data[DOMAIN]["coordinator"],
hass,
chargerApi,
f"switch.goecharger_{chargerName}_{attribute}",
chargerName,
"Charging allowed",
attribute,
)
)
async_add_entities(entities)
async def async_get_config_entry_diagnostics(
hass: HomeAssistant, config_entry: ConfigEntry
) -> dict:
"""Return diagnostics for a config entry."""
data_handler: NetatmoDataHandler = hass.data[DOMAIN][config_entry.entry_id][
DATA_HANDLER
]
diagnostics_data = {
"info": {
**config_entry.as_dict(),
"webhook_registered": data_handler.webhook,
},
"data": data_handler.data,
}
if "token" in diagnostics_data["info"]["data"]:
diagnostics_data["info"]["data"]["token"]["access_token"] = REDACTED
diagnostics_data["info"]["data"]["token"]["refresh_token"] = REDACTED
diagnostics_data["info"]["data"]["token"]["restricted_access_token"] = REDACTED
diagnostics_data["info"]["data"]["token"]["restricted_refresh_token"] = REDACTED
if "webhook_id" in diagnostics_data["info"]["data"]:
diagnostics_data["info"]["data"]["webhook_id"] = REDACTED
if "weather_areas" in diagnostics_data["info"].get("options", {}):
for area in diagnostics_data["info"]["options"]["weather_areas"]:
for attr in ("lat_ne", "lat_sw", "lon_ne", "lon_sw"):
diagnostics_data["info"]["options"]["weather_areas"][area][
attr
] = REDACTED
return diagnostics_data
def _async_get_diagnostics(
hass: HomeAssistant,
entry: ConfigEntry,
device: DeviceEntry | None = None,
) -> dict:
"""Return diagnostics for a config or a device entry."""
diag_data = {"entry": async_redact_data(entry.as_dict(), TO_REDACT)}
lg_device_id = None
if device:
lg_device_id = next(iter(device.identifiers))[1]
devs_data = _async_devices_as_dict(hass, lg_device_id)
diag_data[LGE_DEVICES] = devs_data
if device:
return diag_data
# Get info for unsupported device if diagnostic is for the config entry
unsup_devices = hass.data[DOMAIN].get(UNSUPPORTED_DEVICES, {})
unsup_data = {}
for dev_type, devices in unsup_devices.items():
unsup_devs = [
async_redact_data(device.as_dict(), TO_REDACT_DEV)
for device in devices
]
unsup_data[dev_type.name] = unsup_devs
if unsup_data:
diag_data[UNSUPPORTED_DEVICES] = unsup_data
return diag_data
async def async_get_config_entry_diagnostics(
hass: HomeAssistant, config_entry: ConfigEntry) -> dict[str, Any]:
"""Return diagnostics for a config entry."""
gateway = get_gateway_from_config_entry(hass, config_entry)
diag: dict[str, Any] = {}
diag["config"] = async_redact_data(config_entry.as_dict(), REDACT_CONFIG)
diag["deconz_config"] = async_redact_data(gateway.api.config.raw,
REDACT_DECONZ_CONFIG)
diag["websocket_state"] = (gateway.api.websocket.state.value
if gateway.api.websocket else "Unknown")
diag["deconz_ids"] = gateway.deconz_ids
diag["entities"] = gateway.entities
diag["events"] = {
event.serial: {
"event_id": event.event_id,
"event_type": type(event).__name__,
}
for event in gateway.events
}
diag["alarm_systems"] = {
k: v.raw
for k, v in gateway.api.alarm_systems.items()
}
diag["groups"] = {k: v.raw for k, v in gateway.api.groups.items()}
diag["lights"] = {k: v.raw for k, v in gateway.api.lights.items()}
diag["scenes"] = {k: v.raw for k, v in gateway.api.scenes.items()}
diag["sensors"] = {k: v.raw for k, v in gateway.api.sensors.items()}
return diag
async def async_get_config_entry_diagnostics(
hass: HomeAssistant,
config_entry: ConfigEntry) -> dict[str, dict[str, Any]]:
"""Return diagnostics for a config entry."""
data = {
"config_entry": async_redact_data(config_entry.as_dict(), TO_REDACT)
}
plenticore: Plenticore = hass.data[DOMAIN][config_entry.entry_id]
# Get information from Kostal Plenticore library
available_process_data = await plenticore.client.get_process_data()
available_settings_data = await plenticore.client.get_settings()
data["client"] = {
"version": str(await plenticore.client.get_version()),
"me": str(await plenticore.client.get_me()),
"available_process_data": available_process_data,
"available_settings_data": {
module_id: [str(setting) for setting in settings]
for module_id, settings in available_settings_data.items()
},
}
device_info = {**plenticore.device_info}
device_info["identifiers"] = REDACTED # contains serial number
data["device"] = device_info
return data
async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry,
async_add_devices):
_LOGGER.info('async_setup_entry()')
_LOGGER.info(entry.as_dict())
config = entry.data
_LOGGER.info(config)
hostname = config[const.CONF_HOST]
port = config[const.CONF_PORT]
password = config[const.CONF_PASSWORD]
host = FahHost(hostname=hostname, port=port, password=password)
num_slots = host.num_slots()
async_add_devices([host])
hass.data[const.DOMAIN]['host_entities'].append(host)
slots = []
for slot_id in range(0, num_slots):
_LOGGER.info("building slot %d" % slot_id)
slot = FahSlot(slot_id=slot_id, host=host)
slots.append(slot)
if slots:
hass.data[const.DOMAIN]['slot_entities'].extend(slots)
async_add_devices(slots)
_LOGGER.info(hass.data[const.DOMAIN])
async def async_get_config_entry_diagnostics(
hass: HomeAssistant, entry: ConfigEntry
) -> dict[str, Any]:
"""Return diagnostics for a config entry."""
return {
"entry": async_redact_data(entry.as_dict(), TO_REDACT),
}
async def async_get_config_entry_diagnostics(
hass: HomeAssistant, config_entry: ConfigEntry) -> dict[str, Any]:
"""Return diagnostics for a config entry."""
device: AxisNetworkDevice = hass.data[AXIS_DOMAIN][config_entry.unique_id]
diag: dict[str, Any] = {}
diag["config"] = async_redact_data(config_entry.as_dict(), REDACT_CONFIG)
if device.api.vapix.api_discovery:
diag["api_discovery"] = [{
"id": api.id,
"name": api.name,
"version": api.version
} for api in device.api.vapix.api_discovery.values()]
if device.api.vapix.basic_device_info:
diag["basic_device_info"] = async_redact_data(
{
attr.id: attr.raw
for attr in device.api.vapix.basic_device_info.values()
},
REDACT_BASIC_DEVICE_INFO,
)
if device.api.vapix.params:
diag["params"] = async_redact_data(
{
param.id: param.raw
for param in device.api.vapix.params.values()
},
REDACT_VAPIX_PARAMS,
)
return diag
async def async_get_config_entry_diagnostics(
hass: HomeAssistant, config_entry: ConfigEntry) -> dict:
"""Return diagnostics for a config entry."""
data_handler: NetatmoDataHandler = hass.data[DOMAIN][
config_entry.entry_id][DATA_HANDLER]
return {
"info":
async_redact_data(
{
**config_entry.as_dict(),
"webhook_registered":
data_handler.webhook,
},
TO_REDACT,
),
"data": {
CLIMATE_TOPOLOGY_CLASS_NAME:
async_redact_data(
getattr(data_handler.data[CLIMATE_TOPOLOGY_CLASS_NAME],
"raw_data"),
TO_REDACT,
)
},
}
async def async_get_config_entry_diagnostics(
hass: HomeAssistant,
config_entry: ConfigEntry,
) -> dict:
"""Return diagnostics for a config entry."""
device: Nanoleaf = hass.data[DOMAIN][config_entry.entry_id].device
return {
"info": async_redact_data(config_entry.as_dict(), (CONF_TOKEN, "title")),
"data": {
"brightness_max": device.brightness_max,
"brightness_min": device.brightness_min,
"brightness": device.brightness,
"color_mode": device.color_mode,
"color_temperature_max": device.color_temperature_max,
"color_temperature_min": device.color_temperature_min,
"color_temperature": device.color_temperature,
"effect": device.effect,
"effects_list": device.effects_list,
"firmware_version": device.firmware_version,
"hue_max": device.hue_max,
"hue_min": device.hue_min,
"hue": device.hue,
"is_on": device.is_on,
"manufacturer": device.manufacturer,
"port": device.port,
"saturation_max": device.saturation_max,
"saturation_min": device.saturation_min,
"saturation": device.saturation,
"serial_no": device.serial_no,
},
}
async def async_get_config_entry_diagnostics(
hass: HomeAssistant, config_entry: ConfigEntry) -> dict:
"""Return diagnostics for a config entry."""
config: dict = hass.data[DATA_ZHA].get(DATA_ZHA_CONFIG, {})
gateway: ZHAGateway = hass.data[DATA_ZHA][DATA_ZHA_GATEWAY]
return async_redact_data(
{
"config":
config,
"config_entry":
config_entry.as_dict(),
"application_state":
shallow_asdict(gateway.application_controller.state),
"versions": {
"bellows": bellows.__version__,
"zigpy": zigpy.__version__,
"zigpy_deconz": zigpy_deconz.__version__,
"zigpy_xbee": zigpy_xbee.__version__,
"zigpy_znp": zigpy_znp.__version__,
"zigpy_zigate": zigpy_zigate.__version__,
"zhaquirks":
pkg_resources.get_distribution("zha-quirks").version,
},
},
KEYS_TO_REDACT,
)
async def async_get_config_entry_diagnostics(
hass: HomeAssistant, config_entry: ConfigEntry # pylint: disable=unused-argument
) -> dict[str, Any]:
"""Return diagnostics for a config entry."""
diag: dict[str, Any] = {}
diag["config"] = config_entry.as_dict()
return async_redact_data(diag, REDACT_KEYS)
async def async_get_config_entry_diagnostics(
hass: HomeAssistant, entry: ConfigEntry) -> dict[str, Any]:
"""Return diagnostics for a config entry."""
controller = hass.data[DOMAIN][entry.entry_id]["cntrl"]
data: dict[str, Any] = {"entry": entry.as_dict(), "modules": []}
for module in controller.get_modules().values():
data["modules"].append(_build_module_diagnostics_info(module))
return data
async def async_get_config_entry_diagnostics(
hass: HomeAssistant, entry: ConfigEntry) -> dict[str, Any]:
"""Return diagnostics for a config entry."""
bridge: SamsungTVBridge = hass.data[DOMAIN][entry.entry_id]
return {
"entry": async_redact_data(entry.as_dict(), TO_REDACT),
"device_info": await bridge.async_device_info(),
}
async def async_get_config_entry_diagnostics(
hass: HomeAssistant, entry: ConfigEntry) -> dict[str, dict[str, Any]]:
"""Return diagnostics for a config entry."""
data = {"entry": async_redact_data(entry.as_dict(), TO_REDACT)}
router: AsusWrtRouter = hass.data[DOMAIN][entry.entry_id][DATA_ASUSWRT]
# Gather information how this AsusWrt device is represented in Home Assistant
device_registry = dr.async_get(hass)
entity_registry = er.async_get(hass)
hass_device = device_registry.async_get_device(
identifiers=router.device_info["identifiers"])
if not hass_device:
return data
data["device"] = {
**async_redact_data(attr.asdict(hass_device), TO_REDACT_DEV),
"entities": {},
"tracked_devices": [],
}
hass_entities = er.async_entries_for_device(
entity_registry,
device_id=hass_device.id,
include_disabled_entities=True,
)
for entity_entry in hass_entities:
state = hass.states.get(entity_entry.entity_id)
state_dict = None
if state:
state_dict = dict(state.as_dict())
# The entity_id is already provided at root level.
state_dict.pop("entity_id", None)
# The context doesn't provide useful information in this case.
state_dict.pop("context", None)
data["device"]["entities"][entity_entry.entity_id] = {
**async_redact_data(
attr.asdict(entity_entry,
filter=lambda attr, value: attr.name != "entity_id"),
TO_REDACT,
),
"state":
state_dict,
}
for device in router.devices.values():
data["device"]["tracked_devices"].append({
"name":
device.name or "Unknown device",
"ip_address":
device.ip_address,
"last_activity":
device.last_activity,
})
return data
async def async_get_config_entry_diagnostics(
hass: HomeAssistant, entry: ConfigEntry) -> dict[str, Any]:
"""Return diagnostics for a config entry."""
coordinator: DataUpdateCoordinator = hass.data[DOMAIN][entry.entry_id]
return {
"entry": entry.as_dict(),
"data": [dataclasses.asdict(event) for event in coordinator.data],
}
async def async_get_config_entry_diagnostics(
hass: HomeAssistant, config_entry: ConfigEntry) -> dict:
"""Return diagnostics for a config entry."""
coordinator: EagleDataCoordinator = hass.data[DOMAIN][
config_entry.entry_id]
return {
"config_entry": async_redact_data(config_entry.as_dict(), TO_REDACT),
"data": coordinator.data,
}
async def async_get_config_entry_diagnostics(
hass: HomeAssistant, config_entry: ConfigEntry) -> dict:
"""Return diagnostics for a config entry."""
coordinator: ScreenlogicDataUpdateCoordinator = hass.data[DOMAIN][
config_entry.entry_id]
return {
"config_entry": config_entry.as_dict(),
"data": coordinator.data,
}
async def options_update_listener(hass: HomeAssistant,
config_entry: ConfigEntry):
"""Handle options update."""
_LOGGER.debug("Updated options")
entry_data = config_entry.as_dict().get("data")
hass.config_entries.async_update_entry(
config_entry,
data=entry_data,
)
_LOGGER.debug("Reload entry: " + config_entry.entry_id)
await hass.config_entries.async_reload(config_entry.entry_id)
async def async_get_config_entry_diagnostics(
hass: HomeAssistant, entry: ConfigEntry) -> dict[str, dict[str, Any]]:
"""Return diagnostics for a config entry."""
data = {"entry": async_redact_data(entry.as_dict(), TO_REDACT)}
hass_data = hass.data[DOMAIN][entry.entry_id]
# Get information from AndroidTV library
aftv = hass_data[ANDROID_DEV]
data["device_properties"] = {
**async_redact_data(aftv.device_properties, TO_REDACT_DEV_PROP),
"device_class":
aftv.DEVICE_CLASS,
}
# Gather information how this AndroidTV device is represented in Home Assistant
device_registry = dr.async_get(hass)
entity_registry = er.async_get(hass)
hass_device = device_registry.async_get_device(
identifiers={(DOMAIN, str(entry.unique_id))})
if not hass_device:
return data
data["device"] = {
**async_redact_data(attr.asdict(hass_device), TO_REDACT_DEV),
"entities": {},
}
hass_entities = er.async_entries_for_device(
entity_registry,
device_id=hass_device.id,
include_disabled_entities=True,
)
for entity_entry in hass_entities:
state = hass.states.get(entity_entry.entity_id)
state_dict = None
if state:
state_dict = dict(state.as_dict())
# The entity_id is already provided at root level.
state_dict.pop("entity_id", None)
# The context doesn't provide useful information in this case.
state_dict.pop("context", None)
data["device"]["entities"][entity_entry.entity_id] = {
**async_redact_data(
attr.asdict(entity_entry,
filter=lambda attr, value: attr.name != "entity_id"),
TO_REDACT,
),
"state":
state_dict,
}
return data
async def async_get_config_entry_diagnostics(
hass: HomeAssistant, config_entry: ConfigEntry) -> dict[str, Any]:
"""Return diagnostics for a config entry."""
coordinator: QswUpdateCoordinator = hass.data[DOMAIN][
config_entry.entry_id]
return {
"config_entry": async_redact_data(config_entry.as_dict(),
TO_REDACT_CONFIG),
"coord_data": async_redact_data(coordinator.data, TO_REDACT_DATA),
}
async def async_get_config_entry_diagnostics(hass: HomeAssistant,
entry: ConfigEntry) -> dict:
"""Return diagnostics for a config entry."""
instance: CoinbaseData = hass.data[DOMAIN][entry.entry_id]
return async_redact_data(
{
"entry": entry.as_dict(),
"accounts": instance.accounts,
},
TO_REDACT,
)
async def async_get_config_entry_diagnostics(
hass: HomeAssistant, config_entry: ConfigEntry) -> dict[str, Any]:
"""Return diagnostics for a config entry."""
diag: dict[str, Any] = {}
diag["config"] = config_entry.as_dict()
entry_data = DomainData.get(hass).get_entry_data(config_entry)
if (storage_data := await entry_data.store.async_load()) is not None:
storage_data = cast("dict[str, Any]", storage_data)
diag["storage_data"] = storage_data
async def async_setup_entry(
hass: core.HomeAssistant,
config_entry: config_entries.ConfigEntry,
async_add_entities,
):
_LOGGER.debug("setup sensors...")
config = config_entry.as_dict()["data"]
chargerName = config[CONF_NAME]
_LOGGER.debug(f"charger name: '{chargerName}'")
async_add_entities(_create_sensors_for_charger(chargerName, hass))
async def async_get_config_entry_diagnostics(
hass: HomeAssistant, entry: ConfigEntry
) -> dict[str, Any]:
"""Return diagnostics for a config entry."""
# Currently we only support a single device
device = hass.data[DOMAIN][entry.entry_id][VICARE_DEVICE_CONFIG]
data: dict[str, Any] = json.loads(
await hass.async_add_executor_job(device.dump_secure)
)
return {
"entry": async_redact_data(entry.as_dict(), TO_REDACT),
"data": data,
}
async def async_get_config_entry_diagnostics(
hass: HomeAssistant, config_entry: ConfigEntry
) -> dict[str, Any]:
"""Return diagnostics for a config entry."""
entry_data = hass.data[DOMAIN][config_entry.entry_id]
coord_data: QswDataCoordinator = entry_data[QSW_COORD_DATA]
coord_fw: QswFirmwareCoordinator = entry_data[QSW_COORD_FW]
return {
"config_entry": async_redact_data(config_entry.as_dict(), TO_REDACT_CONFIG),
"coord_data": async_redact_data(coord_data.data, TO_REDACT_DATA),
"coord_fw": async_redact_data(coord_fw.data, TO_REDACT_DATA),
}
async def async_get_config_entry_diagnostics(
hass: HomeAssistant, entry: ConfigEntry) -> dict[str, dict[str, Any]]:
"""Return diagnostics for a config entry."""
data = {"entry": async_redact_data(entry.as_dict(), TO_REDACT)}
hass_data = hass.data[DOMAIN][entry.entry_id]
# Get information from Nut library
nut_data: PyNUTData = hass_data[PYNUT_DATA]
data["nut_data"] = {
"ups_list": nut_data.ups_list,
"status": nut_data.status
}
# Gather information how this Nut device is represented in Home Assistant
device_registry = dr.async_get(hass)
entity_registry = er.async_get(hass)
hass_device = device_registry.async_get_device(
identifiers={(DOMAIN, hass_data[PYNUT_UNIQUE_ID])})
if not hass_device:
return data
data["device"] = {
**attr.asdict(hass_device),
"entities": {},
}
hass_entities = er.async_entries_for_device(
entity_registry,
device_id=hass_device.id,
include_disabled_entities=True,
)
for entity_entry in hass_entities:
state = hass.states.get(entity_entry.entity_id)
state_dict = None
if state:
state_dict = dict(state.as_dict())
# The entity_id is already provided at root level.
state_dict.pop("entity_id", None)
# The context doesn't provide useful information in this case.
state_dict.pop("context", None)
data["device"]["entities"][entity_entry.entity_id] = {
**attr.asdict(entity_entry,
filter=lambda attr, value: attr.name != "entity_id"),
"state":
state_dict,
}
return data
async def async_get_config_entry_diagnostics(
hass: HomeAssistant, config_entry: ConfigEntry) -> dict[str, Any]:
"""Return diagnostics for a config entry."""
diagnostics_data: dict[str, Any] = {
"config_entry": async_redact_data(config_entry.as_dict(), TO_REDACT)
}
# not every device uses DataUpdateCoordinator
if coordinator := hass.data[DOMAIN][config_entry.entry_id].get(
KEY_COORDINATOR):
if isinstance(coordinator.data, dict):
diagnostics_data["coordinator_data"] = coordinator.data
else:
diagnostics_data["coordinator_data"] = repr(coordinator.data)
async def async_get_config_entry_diagnostics(
hass: HomeAssistant, config_entry: ConfigEntry) -> dict:
"""Return diagnostics for a config entry."""
trackables = hass.data[DOMAIN][config_entry.entry_id][TRACKABLES]
diagnostics_data = async_redact_data(
{
"config_entry": config_entry.as_dict(),
"trackables": [item.trackable for item in trackables],
},
TO_REDACT,
)
return diagnostics_data
async def async_get_config_entry_diagnostics(
hass: HomeAssistant, entry: ConfigEntry) -> dict[str, Any]:
"""Return diagnostic information."""
data = hass.data[DOMAIN]
config: GoogleConfig = data[entry.entry_id]
yaml_config: ConfigType = data[DATA_CONFIG]
devices = await async_devices_sync_response(hass, config, REDACTED)
sync = create_sync_response(REDACTED, devices)
return {
"config_entry": async_redact_data(entry.as_dict(), TO_REDACT),
"yaml_config": async_redact_data(yaml_config, TO_REDACT),
"sync": async_redact_data(sync, TO_REDACT),
}
