async def async_get_device_diagnostics(
hass: HomeAssistant, entry: ConfigEntry, device: dr.DeviceEntry
) -> dict[str, Any]:
"""Return device diagnostics."""
coordinator = hass.data[DOMAIN][entry.entry_id]
data = coordinator.data
data["settings"] = async_redact_data(data["settings"], SETTINGS_TO_REDACT)
return async_redact_data(data, DEVICE_INFO_TO_REDACT)
async def async_get_config_entry_diagnostics(
hass: HomeAssistant, config_entry: ConfigEntry) -> dict[str, Any]:
"""Return diagnostics for a config entry."""
coordinator: AirzoneUpdateCoordinator = hass.data[DOMAIN][
config_entry.entry_id]
return {
"info": async_redact_data(config_entry.data, TO_REDACT),
"data": async_redact_data(coordinator.data, TO_REDACT),
}
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, 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, config_entry: ConfigEntry) -> dict[str, Any]:
"""Return diagnostics for a config entry."""
coordinator = hass.data[DOMAIN][config_entry.entry_id][DATA_COORDINATOR]
diagnostics_data = {
"info":
async_redact_data(config_entry.data, TO_REDACT_INFO),
"data": [
async_redact_data(vehicle, TO_REDACT_DATA)
for vehicle in coordinator.data
],
}
return diagnostics_data
async def async_get_device_diagnostics(hass: HomeAssistant,
config_entry: ConfigEntry,
device: dr.DeviceEntry) -> dict:
"""Return diagnostics for a device."""
client: Client = hass.data[DOMAIN][config_entry.entry_id][DATA_CLIENT]
identifiers = get_home_and_node_id_from_device_entry(device)
node_id = identifiers[1] if identifiers else None
assert (driver := client.driver)
if node_id is None or node_id not in driver.controller.nodes:
raise ValueError(f"Node for device {device.id} can't be found")
node = driver.controller.nodes[node_id]
entities = get_device_entities(hass, node, device)
assert client.version
node_state = redact_node_state(async_redact_data(node.data,
KEYS_TO_REDACT))
node_state["statistics"] = node.statistics.data
return {
"versionInfo": {
"driverVersion": client.version.driver_version,
"serverVersion": client.version.server_version,
"minSchemaVersion": client.version.min_schema_version,
"maxSchemaVersion": client.version.max_schema_version,
},
"entities": entities,
"state": node_state,
}
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_device_diagnostics(
hass: HomeAssistant, config_entry: ConfigEntry, device: dr.DeviceEntry
) -> dict:
"""Return diagnostics for a device."""
zha_device: ZHADevice = async_get_zha_device(hass, device.id)
device_info: dict[str, Any] = zha_device.zha_device_info
device_info[CLUSTER_DETAILS] = get_endpoint_cluster_attr_data(zha_device)
return async_redact_data(device_info, KEYS_TO_REDACT)
async def async_get_device_diagnostics(hass: HomeAssistant,
config_entry: ConfigEntry,
device: DeviceEntry) -> dict[str, Any]:
"""Return diagnostics for a device."""
coordinator = hass.data[DOMAIN][config_entry.entry_id][DATA_COORDINATOR]
vin = next(iter(device.identifiers))[1]
target_vehicle = None
for vehicle in coordinator.data:
if vehicle["vin"] == vin:
target_vehicle = vehicle
break
if target_vehicle is None:
raise HomeAssistantError("Vehicle not found")
diagnostics_data = {
"info": async_redact_data(config_entry.data, TO_REDACT_INFO),
"data": async_redact_data(target_vehicle, TO_REDACT_DATA),
}
return diagnostics_data
async def async_get_config_entry_diagnostics(
hass: HomeAssistant, config_entry: ConfigEntry
) -> list[dict]:
"""Return diagnostics for a config entry."""
msgs: list[dict] = async_redact_data(
await dump_msgs(config_entry.data[CONF_URL], async_get_clientsession(hass)),
KEYS_TO_REDACT,
)
handshake_msgs = msgs[:-1]
network_state = msgs[-1]
network_state["result"]["state"]["nodes"] = [
redact_node_state(node) for node in network_state["result"]["state"]["nodes"]
]
return [*handshake_msgs, network_state]
async def async_get_device_diagnostics(hass: HomeAssistant,
config_entry: ConfigEntry,
device: dr.DeviceEntry) -> dict:
"""Return diagnostics for a device."""
zha_device: ZHADevice = await async_get_zha_device(hass, device.id)
return async_redact_data(zha_device.zha_device_info, KEYS_TO_REDACT)
async def async_get_config_entry_diagnostics(
hass: HomeAssistant, entry: ConfigEntry
) -> dict[str, Any]:
"""Return diagnostics for a config entry."""
coordinator: SensiboDataUpdateCoordinator = hass.data[DOMAIN][entry.entry_id]
return async_redact_data(coordinator.data.raw, TO_REDACT)