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), }