async def async_get_config_entry_diagnostics(
hass: HomeAssistant, entry: ConfigEntry) -> dict[str, Any]:
"""Return diagnostics for a config entry."""
data: RainMachineData = hass.data[DOMAIN][entry.entry_id]
try:
controller_diagnostics = await data.controller.diagnostics.current()
except RainMachineError:
LOGGER.warning("Unable to download controller-specific diagnostics")
controller_diagnostics = None
return {
"entry": {
"title": entry.title,
"data": async_redact_data(entry.data, TO_REDACT),
"options": dict(entry.options),
},
"data": {
"coordinator":
async_redact_data(
{
api_category: controller.data
for api_category, controller in data.coordinators.items()
},
TO_REDACT,
),
"controller_diagnostics":
controller_diagnostics,
},
}
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[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, entry: ConfigEntry) -> dict[str, Any]:
"""Return diagnostics for a config entry."""
data = hass.data[DOMAIN][entry.entry_id]
coordinators: dict[str,
GuardianDataUpdateCoordinator] = data[DATA_COORDINATOR]
paired_sensor_coordinators: dict[
str,
GuardianDataUpdateCoordinator] = data[DATA_COORDINATOR_PAIRED_SENSOR]
return {
"entry": {
"title": entry.title,
"data": async_redact_data(entry.data, TO_REDACT),
},
"data": {
"valve_controller": {
api_category: async_redact_data(coordinator.data, TO_REDACT)
for api_category, coordinator in coordinators.items()
},
"paired_sensors": [
async_redact_data(coordinator.data, TO_REDACT)
for coordinator in paired_sensor_coordinators.values()
],
},
}
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, entry: ConfigEntry) -> dict[str, Any]:
"""Return diagnostics for a config entry."""
data = hass.data[DOMAIN][entry.entry_id]
coordinators: dict[str, DataUpdateCoordinator] = data[DATA_COORDINATOR]
controller: Controller = data[DATA_CONTROLLER]
return {
"entry": {
"title": entry.title,
"data": async_redact_data(entry.data, TO_REDACT),
"options": dict(entry.options),
},
"data": {
"coordinator":
async_redact_data(
{
api_category: controller.data
for api_category, controller in coordinators.items()
},
TO_REDACT,
),
"controller": {
"api_version": controller.api_version,
"hardware_version": controller.hardware_version,
"name": controller.name,
"software_version": controller.software_version,
},
},
}
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, 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
def _get_vehicle_diagnostics(vehicle: RenaultVehicleProxy) -> dict[str, Any]:
"""Return diagnostics for a device."""
return {
"details": async_redact_data(vehicle.details.raw_data, TO_REDACT),
"data": {
key: async_redact_data(coordinator.data.raw_data, TO_REDACT)
for key, coordinator in vehicle.coordinators.items()
},
}
async def async_get_config_entry_diagnostics(
hass: HomeAssistant, config_entry: ConfigEntry) -> dict:
"""Return diagnostics for a config entry."""
diagnostics_data = {
"account": async_redact_data(config_entry.data, TO_REDACT),
"options": async_redact_data(config_entry.options, TO_REDACT),
}
return diagnostics_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 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, entry: ConfigEntry) -> dict[str, Any]:
"""Return diagnostics for a config entry."""
openuv: OpenUV = hass.data[DOMAIN][entry.entry_id]
return {
"entry": {
"data": async_redact_data(entry.data, TO_REDACT),
"options": async_redact_data(entry.options, TO_REDACT),
},
"data": async_redact_data(openuv.data, TO_REDACT),
}
async def async_get_config_entry_diagnostics(
hass: HomeAssistant, entry: ConfigEntry) -> dict[str, Any]:
"""Return diagnostics for a config entry."""
ambient: AmbientStation = hass.data[DOMAIN][entry.entry_id]
return {
"entry": {
"title": entry.title,
"data": async_redact_data(entry.data, TO_REDACT),
},
"stations": async_redact_data(ambient.stations, TO_REDACT),
}
async def async_get_config_entry_diagnostics(
hass: HomeAssistant, config_entry: ConfigEntry) -> dict[str, Any]:
"""Return diagnostics for a config entry."""
services = []
for service in hass.data[DOMAIN][config_entry.entry_id]["services"]:
services.append({
"service":
async_redact_data(service, TO_REDACT),
"usage":
async_redact_data(service["coordinator"].data, ["historical"]),
})
return {"services": services}
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": {
"title": entry.title,
"data": async_redact_data(entry.data, TO_REDACT),
"options": async_redact_data(entry.options, TO_REDACT),
},
"data": async_redact_data(coordinator.data["data"], TO_REDACT),
}
async def async_get_config_entry_diagnostics(
hass: HomeAssistant, config_entry: ConfigEntry) -> dict[str, Any]:
"""Return diagnostics for a config entry."""
controller: UniFiController = hass.data[UNIFI_DOMAIN][
config_entry.entry_id]
diag: dict[str, Any] = {}
macs_to_redact: dict[str, str] = {}
counter = 0
for mac in chain(controller.api.clients, controller.api.devices):
macs_to_redact[mac] = format_mac(str(counter).zfill(12))
counter += 1
for device in controller.api.devices.values():
for entry in device.raw.get("ethernet_table", []):
mac = entry.get("mac", "")
if mac not in macs_to_redact:
macs_to_redact[mac] = format_mac(str(counter).zfill(12))
counter += 1
diag["config"] = async_redact_data(
async_replace_dict_data(config_entry.as_dict(), macs_to_redact),
REDACT_CONFIG)
diag["site_role"] = controller.site_role
diag["entities"] = async_replace_dict_data(controller.entities,
macs_to_redact)
diag["clients"] = {
macs_to_redact[k]:
async_redact_data(async_replace_dict_data(v.raw, macs_to_redact),
REDACT_CLIENTS)
for k, v in controller.api.clients.items()
}
diag["devices"] = {
macs_to_redact[k]:
async_redact_data(async_replace_dict_data(v.raw, macs_to_redact),
REDACT_DEVICES)
for k, v in controller.api.devices.items()
}
diag["dpi_apps"] = {k: v.raw for k, v in controller.api.dpi_apps.items()}
diag["dpi_groups"] = {
k: v.raw
for k, v in controller.api.dpi_groups.items()
}
diag["wlans"] = {
k: async_redact_data(async_replace_dict_data(v.raw, macs_to_redact),
REDACT_WLANS)
for k, v in controller.api.wlans.items()
}
return diag
async def async_get_device_diagnostics(hass: HomeAssistant,
config_entry: ConfigEntry,
device: DeviceEntry) -> dict[str, Any]:
"""Return diagnostics for a device."""
info = {}
info["manufacturer"] = device.manufacturer
info["model"] = device.model
diagnostics_data = {
"account": async_redact_data(config_entry.data, TO_REDACT),
"data": async_redact_data(info, TO_REDACT_DATA),
}
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),
}
async def async_get_config_entry_diagnostics(hass: HomeAssistant,
entry: ConfigEntry) -> dict:
"""Return diagnostics for a config entry."""
diag_data = {"entry": async_redact_data(entry.as_dict(), TO_REDACT)}
yaml_data = hass.data[DOMAIN].get(entry.unique_id, {})
if yaml_data:
diag_data["config_data"] = async_redact_data(yaml_data, TO_REDACT)
device_id = entry.data.get(CONF_ID, entry.entry_id)
hass_data = _async_device_ha_info(hass, device_id)
if hass_data:
diag_data["device"] = hass_data
return diag_data
async def async_get_config_entry_diagnostics(
hass: HomeAssistant, entry: ConfigEntry) -> dict[str, Any]:
"""Return diagnostics for a config entry."""
coordinator: NexiaDataUpdateCoordinator = hass.data[DOMAIN][entry.entry_id]
nexia_home = coordinator.nexia_home
return {
"entry": {
"title": entry.title,
"brand": entry.data.get(CONF_BRAND),
},
"automations": async_redact_data(nexia_home.automations_json,
TO_REDACT),
"devices": async_redact_data(nexia_home.devices_json, TO_REDACT),
}
async def async_get_config_entry_diagnostics(
hass: HomeAssistant, entry: ConfigEntry) -> dict[str, Any]:
"""Return diagnostics for a config entry."""
options = async_redact_data(entry.options, TO_REDACT)
for key in (CONF_STREAM_SOURCE, CONF_STILL_IMAGE_URL):
if (value := options.get(key)) is not None:
options[key] = redact_url(value)
async def async_get_config_entry_diagnostics(
hass: HomeAssistant, entry: ConfigEntry) -> dict[str, Any]:
"""Return diagnostics for a config entry."""
coordinator: WLEDDataUpdateCoordinator = hass.data[DOMAIN][entry.entry_id]
data: dict[str, Any] = {
"info": async_redact_data(coordinator.data.info.__dict__, "wifi"),
"state": coordinator.data.state.__dict__,
"effects":
{effect.effect_id: effect.name
for effect in coordinator.data.effects},
"palettes": {
palette.palette_id: palette.name
for palette in coordinator.data.palettes
},
"playlists": {
playlist.playlist_id: {
"name": playlist.name,
"repeat": playlist.repeat,
"shuffle": playlist.shuffle,
"end": playlist.end.preset_id if playlist.end else None,
}
for playlist in coordinator.data.playlists
},
"presets": {
preset.preset_id: {
"name": preset.name,
"quick_label": preset.quick_label,
"on": preset.on,
"transition": preset.transition,
}
for preset in coordinator.data.presets
},
}
return data
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, entry: ConfigEntry) -> dict[str, Any]:
"""Return diagnostics for a config entry."""
coordinator: TPLinkDataUpdateCoordinator = hass.data[DOMAIN][
entry.entry_id]
return async_redact_data(
{"device_last_response": coordinator.device.internal_state}, TO_REDACT)
def _async_devices_as_dict(hass: HomeAssistant,
lg_device_id: str | None = None) -> dict:
"""Represent a LGE devices as a dictionary."""
lge_devices = hass.data[DOMAIN].get(LGE_DEVICES, {})
devs_data = {}
for dev_type, devices in lge_devices.items():
lge_devs = {}
for lge_device in devices:
device = lge_device.device
if lg_device_id and device.device_info.id != lg_device_id:
continue
lge_devs[lge_device.unique_id] = {
"device_info":
async_redact_data(device.device_info.as_dict(), TO_REDACT_DEV),
"model_info":
device.model_info.as_dict(),
"device_status":
device.status.data if device.status else None,
"home_assistant":
_async_device_ha_info(hass, device.device_info.id)
}
if lg_device_id:
return {dev_type.name: lge_devs}
if lge_devs:
devs_data[dev_type.name] = lge_devs
return devs_data
def _async_get_diagnostics(
hass: HomeAssistant,
entry: ConfigEntry,
device: DeviceEntry | None = None,
) -> dict[str, Any]:
"""Return diagnostics for a config entry."""
mqtt_instance: MQTT = hass.data[DATA_MQTT]
redacted_config = async_redact_data(mqtt_instance.conf, REDACT_CONFIG)
data = {
"connected": is_connected(hass),
"mqtt_config": redacted_config,
}
if device:
data["device"] = _async_device_as_dict(hass, device)
data["mqtt_debug_info"] = debug_info.info_for_device(hass, device.id)
else:
device_registry = dr.async_get(hass)
data.update(
devices=[
_async_device_as_dict(hass, device)
for device in dr.async_entries_for_config_entry(
device_registry, entry.entry_id)
],
mqtt_debug_info=debug_info.info_for_config_entry(hass),
)
return data
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[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
def _async_device_as_dict(hass: HomeAssistant, device: DeviceEntry) -> dict[str, Any]:
"""Represent a Powerview device as a dictionary."""
# Gather information how this device is represented in Home Assistant
entity_registry = er.async_get(hass)
data = async_redact_data(attr.asdict(device), REDACT_CONFIG)
data["entities"] = []
entities: list[dict[str, Any]] = data["entities"]
entries = er.async_entries_for_device(
entity_registry,
device_id=device.id,
include_disabled_entities=True,
)
for entity_entry in entries:
state = hass.states.get(entity_entry.entity_id)
state_dict = None
if state:
state_dict = dict(state.as_dict())
state_dict.pop("context", None)
entity = attr.asdict(entity_entry)
entity["state"] = state_dict
entities.append(entity)
return data
async def async_get_config_entry_diagnostics(
hass: HomeAssistant, entry: ConfigEntry) -> dict[str, Any]:
"""Return diagnostics for a config entry."""
data: TileData = hass.data[DOMAIN][entry.entry_id]
return async_redact_data(
{"tiles": [tile.as_dict() for tile in data.tiles.values()]}, TO_REDACT)
