async def async_update_data():
try:
return await api.async_info()
except Exception as exception:
raise UpdateFailed(f"Error communicating with API: {exception}"
) from exception
async def _async_update_data(self):
"""Fetch data from Google Wifi API."""
try:
system_data = await self.api.get_systems()
for system_id, system in system_data.items():
connected_count = 0
guest_connected_count = 0
main_network = system["groupSettings"]["lanSettings"].get(
"dhcpPoolBegin", " " * 10
)
main_network = ".".join(main_network.split(".", 3)[:3])
for device_id, device in system["devices"].items():
device_network = device.get("ipAddress", " " * 10)
device_network = ".".join(device_network.split(".", 3)[:3])
if device_id not in self.devicelist:
to_add = {
"system_id": system_id,
"device_id": device_id,
"device": device,
}
async_dispatcher_send(self.hass, SIGNAL_ADD_DEVICE, to_add)
self.devicelist.append(device_id)
if device.get("connected") and main_network == device_network:
connected_count += 1
device["network"] = "main"
elif (
device.get("connected")
and device.get("unfilteredFriendlyType") != "Nest Wifi point"
):
guest_connected_count += 1
device["network"] = "guest"
elif device.get("unfilteredFriendlyType") == "Nest Wifi point":
connected_count += 1
device["network"] = "main"
for known_device in self.devicelist:
if known_device not in system["devices"]:
async_dispatcher_send(
self.hass, SIGNAL_DELETE_DEVICE, known_device
)
self.devicelist.remove(known_device)
system_data[system_id]["connected_devices"] = connected_count
system_data[system_id]["guest_devices"] = guest_connected_count
system_data[system_id]["total_devices"] = (
connected_count + guest_connected_count
)
if (
time.time()
> (self._last_speedtest + (60 * 60 * self.speedtest_interval))
and self.auto_speedtest == True
and self.hass.state == CoreState.running
):
for system_id, system in system_data.items():
speedtest_result = await self.api.run_speed_test(
system_id=system_id
)
system_data[system_id]["speedtest"] = speedtest_result
self._last_speedtest = time.time()
elif self._force_speed_update:
speedtest_result = await self.api.run_speed_test(system_id=system_id)
system_data[system_id]["speedtest"] = speedtest_result
self._force_speed_update = None
return system_data
except GoogleWifiException as error:
session = aiohttp_client.async_create_clientsession(self.hass)
self.api = GoogleWifi(refresh_token=self.refresh_token, session=session)
except GoogleHomeIgnoreDevice as error:
raise UpdateFailed(f"Error connecting to GoogleWifi: {error}") from error
except ConnectionError as error:
raise PlatformNotReady(
f"Error connecting to GoogleWifi: {error}"
) from error
except ValueError as error:
raise ConfigEntryNotReady(
f"Invalid data from GoogleWifi: {error}"
) from error
async def _async_update_data(self):
"""Update data via library."""
try:
return await self.api.async_get_data()
except Exception as exception:
raise UpdateFailed() from exception
async def async_update(self):
"""Get updated data from SimpliSafe."""
async def async_update_system(system):
"""Update a system."""
await system.update(cached=system.version != 3)
self._async_process_new_notifications(system)
tasks = [
async_update_system(system) for system in self.systems.values()
]
results = await asyncio.gather(*tasks, return_exceptions=True)
for result in results:
if isinstance(result, InvalidCredentialsError):
if self._emergency_refresh_token_used:
matching_flows = [
flow for flow in
self._hass.config_entries.flow.async_progress()
if flow["context"].get("source") == SOURCE_REAUTH
and flow["context"].get(
"unique_id") == self.config_entry.unique_id
]
if not matching_flows:
self._hass.async_create_task(
self._hass.config_entries.flow.async_init(
DOMAIN,
context={
"source": SOURCE_REAUTH,
"unique_id": self.config_entry.unique_id,
},
data=self.config_entry.data,
))
raise UpdateFailed(
"Update failed with stored refresh token")
LOGGER.warning(
"SimpliSafe cloud error; trying stored refresh token")
self._emergency_refresh_token_used = True
try:
await self._api.refresh_access_token(
self.config_entry.data[CONF_TOKEN])
return
except SimplipyError as err:
raise UpdateFailed( # pylint: disable=raise-missing-from
f"Error while using stored refresh token: {err}")
if isinstance(result, EndpointUnavailable):
# In case the user attempts an action not allowed in their current plan,
# we merely log that message at INFO level (so the user is aware,
# but not spammed with ERROR messages that they cannot change):
LOGGER.info(result)
if isinstance(result, SimplipyError):
raise UpdateFailed(
f"SimpliSafe error while updating: {result}")
if self._api.refresh_token != self.config_entry.data[CONF_TOKEN]:
_async_save_refresh_token(self._hass, self.config_entry,
self._api.refresh_token)
# If we've reached this point using an emergency refresh token, we're in the
# clear and we can discard it:
if self._emergency_refresh_token_used:
self._emergency_refresh_token_used = False
async def _async_update_data(self) -> IPPPrinter:
"""Fetch data from IPP."""
try:
return await self.ipp.printer()
except IPPError as error:
raise UpdateFailed(f"Invalid response from API: {error}") from error
async def async_update_data():
"""Fetch data from API endpoint."""
try:
return await tankerkoenig.fetch_data()
except LookupError:
raise UpdateFailed("Failed to fetch data")
async def init_data(self):
"""Initialize the UpdateCoordinator object"""
try:
await self._device.init_data()
except Exception as err:
raise UpdateFailed(f"Init failed: {err}") from err
async def _async_update_data(self) -> SensiboData:
"""Fetch data from Sensibo."""
devices = []
try:
data = await self.client.async_get_devices()
for dev in data["result"]:
devices.append(dev)
except AuthenticationError as error:
raise ConfigEntryAuthFailed from error
except SensiboError as error:
raise UpdateFailed from error
if not devices:
raise UpdateFailed("No devices found")
device_data: dict[str, Any] = {}
for dev in devices:
unique_id = dev["id"]
mac = dev["macAddress"]
name = dev["room"]["name"]
temperature = dev["measurements"].get("temperature")
humidity = dev["measurements"].get("humidity")
ac_states = dev["acState"]
target_temperature = ac_states.get("targetTemperature")
hvac_mode = ac_states.get("mode")
running = ac_states.get("on")
fan_mode = ac_states.get("fanLevel")
swing_mode = ac_states.get("swing")
horizontal_swing_mode = ac_states.get("horizontalSwing")
light_mode = ac_states.get("light")
available = dev["connectionStatus"].get("isAlive", True)
capabilities = dev["remoteCapabilities"]
hvac_modes = list(capabilities["modes"])
if hvac_modes:
hvac_modes.append("off")
current_capabilities = capabilities["modes"][ac_states.get("mode")]
fan_modes = current_capabilities.get("fanLevels")
swing_modes = current_capabilities.get("swing")
horizontal_swing_modes = current_capabilities.get("horizontalSwing")
light_modes = current_capabilities.get("light")
temperature_unit_key = dev.get("temperatureUnit") or ac_states.get(
"temperatureUnit"
)
temperatures_list = (
current_capabilities["temperatures"]
.get(temperature_unit_key, {})
.get("values", [0, 1])
)
if temperatures_list:
diff = MAX_POSSIBLE_STEP
for i in range(len(temperatures_list) - 1):
if temperatures_list[i + 1] - temperatures_list[i] < diff:
diff = temperatures_list[i + 1] - temperatures_list[i]
temperature_step = diff
active_features = list(ac_states)
full_features = set()
for mode in capabilities["modes"]:
if "temperatures" in capabilities["modes"][mode]:
full_features.add("targetTemperature")
if "swing" in capabilities["modes"][mode]:
full_features.add("swing")
if "fanLevels" in capabilities["modes"][mode]:
full_features.add("fanLevel")
if "horizontalSwing" in capabilities["modes"][mode]:
full_features.add("horizontalSwing")
if "light" in capabilities["modes"][mode]:
full_features.add("light")
state = hvac_mode if hvac_mode else "off"
fw_ver = dev["firmwareVersion"]
fw_type = dev["firmwareType"]
model = dev["productModel"]
calibration_temp = dev["sensorsCalibration"].get("temperature")
calibration_hum = dev["sensorsCalibration"].get("humidity")
# Sky plus supports functionality to use motion sensor as sensor for temp and humidity
if main_sensor := dev["mainMeasurementsSensor"]:
measurements = main_sensor["measurements"]
temperature = measurements.get("temperature")
humidity = measurements.get("humidity")
motion_sensors: dict[str, Any] = {}
if dev["motionSensors"]:
for sensor in dev["motionSensors"]:
measurement = sensor["measurements"]
motion_sensors[sensor["id"]] = MotionSensor(
id=sensor["id"],
alive=sensor["connectionStatus"].get("isAlive"),
motion=measurement.get("motion"),
fw_ver=sensor.get("firmwareVersion"),
fw_type=sensor.get("firmwareType"),
is_main_sensor=sensor.get("isMainSensor"),
battery_voltage=measurement.get("batteryVoltage"),
humidity=measurement.get("humidity"),
temperature=measurement.get("temperature"),
model=sensor.get("productModel"),
rssi=measurement.get("rssi"),
)
# Add information for pure devices
pure_conf = dev["pureBoostConfig"]
pure_sensitivity = pure_conf.get("sensitivity") if pure_conf else None
pure_boost_enabled = pure_conf.get("enabled") if pure_conf else None
pm25 = dev["measurements"].get("pm25")
# Binary sensors for main device
room_occupied = dev["roomIsOccupied"]
update_available = bool(
dev["firmwareVersion"] != dev["currentlyAvailableFirmwareVersion"]
)
device_data[unique_id] = {
"id": unique_id,
"mac": mac,
"name": name,
"ac_states": ac_states,
"temp": temperature,
"humidity": humidity,
"target_temp": target_temperature,
"hvac_mode": hvac_mode,
"on": running,
"fan_mode": fan_mode,
"swing_mode": swing_mode,
"horizontal_swing_mode": horizontal_swing_mode,
"light_mode": light_mode,
"available": available,
"hvac_modes": hvac_modes,
"fan_modes": fan_modes,
"swing_modes": swing_modes,
"horizontal_swing_modes": horizontal_swing_modes,
"light_modes": light_modes,
"temp_unit": temperature_unit_key,
"temp_list": temperatures_list,
"temp_step": temperature_step,
"active_features": active_features,
"full_features": full_features,
"state": state,
"fw_ver": fw_ver,
"fw_type": fw_type,
"model": model,
"calibration_temp": calibration_temp,
"calibration_hum": calibration_hum,
"full_capabilities": capabilities,
"motion_sensors": motion_sensors,
"pure_sensitivity": pure_sensitivity,
"pure_boost_enabled": pure_boost_enabled,
"pm25": pm25,
"room_occupied": room_occupied,
"update_available": update_available,
}
async def _async_update_data():
"""Fetch data from Met Éireann."""
try:
return await weather_data.fetch_data()
except Exception as err:
raise UpdateFailed(f"Update failed: {err}") from err
async def async_update_data() -> dict[str, Any] | None:
try:
return await client.async_get_cameras()
except MotionEyeClientError as exc:
raise UpdateFailed("Error communicating with API") from exc
async def async_update_data():
try:
client = hass.data[DOMAIN_DATA][DATA_CLIENT]
await hass.async_add_executor_job(client.update_data)
except Exception as e:
raise UpdateFailed(f"Error communicating with server: {e}")
async def _async_update_data(self):
try:
await self.async_send_message(json.dumps(POLL_REFRESH_MESSAGE))
return self.data
except Exception as exception:
raise UpdateFailed() from exception
async def async_update_data():
"""Fetch data from API endpoint."""
try:
await api.get_state()
except exceptions.ConnectError as err:
raise UpdateFailed("Failed to communicate with device") from err
async def _async_update_data(self) -> dict[str, Any]:
"""Update data via library."""
try:
await self.force_data_refresh()
except HassioAPIError as err:
raise UpdateFailed(f"Error on Supervisor API: {err}") from err
new_data = {}
supervisor_info = get_supervisor_info(self.hass)
addons_info = get_addons_info(self.hass)
addons_stats = get_addons_stats(self.hass)
addons_changelogs = get_addons_changelogs(self.hass)
store_data = get_store(self.hass)
repositories = {
repo[ATTR_SLUG]: repo[ATTR_NAME]
for repo in store_data.get("repositories", [])
}
new_data[DATA_KEY_ADDONS] = {
addon[ATTR_SLUG]: {
**addon,
**((addons_stats or {}).get(addon[ATTR_SLUG]) or {}),
ATTR_AUTO_UPDATE: (addons_info.get(addon[ATTR_SLUG])
or {}).get(ATTR_AUTO_UPDATE, False),
ATTR_CHANGELOG: (addons_changelogs
or {}).get(addon[ATTR_SLUG]),
ATTR_REPOSITORY:
repositories.get(addon.get(ATTR_REPOSITORY),
addon.get(ATTR_REPOSITORY, "")),
}
for addon in supervisor_info.get("addons", [])
}
if self.is_hass_os:
new_data[DATA_KEY_OS] = get_os_info(self.hass)
new_data[DATA_KEY_CORE] = get_core_info(self.hass)
new_data[DATA_KEY_SUPERVISOR] = supervisor_info
# If this is the initial refresh, register all addons and return the dict
if not self.data:
async_register_addons_in_dev_reg(
self.entry_id, self.dev_reg,
new_data[DATA_KEY_ADDONS].values())
async_register_core_in_dev_reg(self.entry_id, self.dev_reg,
new_data[DATA_KEY_CORE])
async_register_supervisor_in_dev_reg(self.entry_id, self.dev_reg,
new_data[DATA_KEY_SUPERVISOR])
if self.is_hass_os:
async_register_os_in_dev_reg(self.entry_id, self.dev_reg,
new_data[DATA_KEY_OS])
# Remove add-ons that are no longer installed from device registry
supervisor_addon_devices = {
list(device.identifiers)[0][1]
for device in self.dev_reg.devices.values()
if self.entry_id in device.config_entries
and device.model == SupervisorEntityModel.ADDON
}
if stale_addons := supervisor_addon_devices - set(
new_data[DATA_KEY_ADDONS]):
async_remove_addons_from_dev_reg(self.dev_reg, stale_addons)
async def async_update_data_dimmer():
"""Fetch data from Control4 director for dimmer lights."""
try:
return await director_update_data(hass, entry, CONTROL4_DIMMER_VAR)
except C4Exception as err:
raise UpdateFailed(f"Error communicating with API: {err}") from err
async def async_update_data():
await hass.async_add_executor_job(sensor.update)
if not sensor.sample_ok:
raise UpdateFailed(f"Bad update of sensor {name}")
return sensor
async def _async_update():
"""Update the device state."""
try:
await led_ble.update()
except BLEAK_EXCEPTIONS as ex:
raise UpdateFailed(str(ex)) from ex
async def update_sensors(vue, scales):
try:
# Note: asyncio.TimeoutError and aiohttp.ClientError are already
# handled by the data update coordinator.
data = {}
loop = asyncio.get_event_loop()
for scale in scales:
now = datetime.utcnow() - timedelta(seconds=1)
channels = await loop.run_in_executor(
None, vue.get_devices_usage, device_gids, now, scale
)
if not channels:
_LOGGER.warn(
f"No channels found during update for scale {scale}. Retrying..."
)
channels = await loop.run_in_executor(
None, vue.get_devices_usage, device_gids, now, scale
)
if channels:
for channel in channels:
id = "{0}-{1}-{2}".format(
channel.device_gid, channel.channel_num, scale
)
usage = round(channel.usage, 3)
if scale == Scale.MINUTE.value:
usage = round(
60 * 1000 * channel.usage
) # convert from kwh to w rate
elif scale == Scale.SECOND.value:
usage = round(3600 * 1000 * channel.usage) # convert to rate
elif scale == Scale.MINUTES_15.value:
usage = round(
4 * 1000 * channel.usage
) # this might never be used but for safety, convert to rate
info = None
if channel.device_gid in device_information:
info = device_information[channel.device_gid]
if channel.channel_num in ["MainsFromGrid", "MainsToGrid"]:
found = False
channel_123 = None
for channel2 in info.channels:
if channel2.channel_num == channel.channel_num:
found = True
break
elif channel2.channel_num == "1,2,3":
channel_123 = channel2
if not found:
_LOGGER.info(
f"Adding channel for channel {channel.device_gid}-{channel.channel_num}"
)
info.channels.append(
VueDeviceChannel(
gid=channel.device_gid,
name=None,
channelNum=channel.channel_num,
channelMultiplier=channel_123.channel_multiplier,
channelTypeGid=channel_123.channel_type_gid,
)
)
data[id] = {
"device_gid": channel.device_gid,
"channel_num": channel.channel_num,
"usage": usage,
"scale": scale,
"info": info,
}
else:
raise UpdateFailed(f"No channels found during update for scale {scale}")
return data
except Exception as err:
_LOGGER.error(f"Error communicating with Emporia API: {err}")
raise UpdateFailed(f"Error communicating with Emporia API: {err}")
async def async_update_data(self):
"""Fetch data"""
try:
return await self._device.fetch_data()
except Exception as err:
raise UpdateFailed(f"Update failed: {err}") from err
async def _update_method():
"""Get the latest data from Airthings."""
try:
return await airthings.update_devices()
except AirthingsError as err:
raise UpdateFailed(f"Unable to fetch data: {err}") from err
async def _async_update_data(self) -> Status:
"""Fetch data from Toon."""
try:
return await self.toon.update()
except ToonError as error:
raise UpdateFailed(f"Invalid response from API: {error}")
async def _async_update_data(self) -> Dict[str, Device]:
"""Fetch TaHoma data via event listener."""
try:
events = await self.client.fetch_events()
except BadCredentialsException as exception:
raise UpdateFailed("Invalid authentication.") from exception
except TooManyRequestsException as exception:
raise UpdateFailed(
"Too many requests, try again later.") from exception
except MaintenanceException as exception:
raise UpdateFailed(
"Server is down for maintenance.") from exception
except TimeoutError as exception:
raise UpdateFailed("Failed to connect.") from exception
except (ServerDisconnectedError, NotAuthenticatedException):
self.executions = {}
await self.client.login()
self.devices = await self._get_devices()
return self.devices
except Exception as exception:
_LOGGER.debug(exception)
raise UpdateFailed(exception) from exception
for event in events:
_LOGGER.debug(
"%s/%s (device: %s, state: %s -> %s)",
event.name,
event.exec_id,
event.deviceurl,
event.old_state,
event.new_state,
)
if event.name == EventName.DEVICE_AVAILABLE:
self.devices[event.deviceurl].available = True
elif event.name in [
EventName.DEVICE_UNAVAILABLE,
EventName.DEVICE_DISABLED,
]:
self.devices[event.deviceurl].available = False
elif event.name in [
EventName.DEVICE_CREATED,
EventName.DEVICE_UPDATED,
]:
self.devices = await self._get_devices()
elif event.name == EventName.DEVICE_REMOVED:
registry = await device_registry.async_get_registry(self.hass)
registry.async_remove_device(event.deviceurl)
del self.devices[event.deviceurl]
elif event.name == EventName.DEVICE_STATE_CHANGED:
for state in event.device_states:
device = self.devices[event.deviceurl]
if state.name not in device.states:
device.states[state.name] = state
device.states[state.name].value = self._get_state(state)
elif event.name == EventName.EXECUTION_REGISTERED:
if event.exec_id not in self.executions:
self.executions[event.exec_id] = {}
self.update_interval = timedelta(seconds=1)
elif (event.name == EventName.EXECUTION_STATE_CHANGED
and event.exec_id in self.executions and event.new_state
in [ExecutionState.COMPLETED, ExecutionState.FAILED]):
del self.executions[event.exec_id]
if not self.executions:
self.update_interval = self.original_update_interval
return self.devices
async def async_update_data():
"""Fetch data from API endpoint.
This is the place to pre-process the data to lookup tables
so entities can quickly look up their data.
This will ping Alexa API to identify all devices, bluetooth, and the last
called device.
This will add new devices and services when discovered. By default this
runs every SCAN_INTERVAL seconds unless another method calls it. if
websockets is connected, it will increase the delay 10-fold between updates.
While throttled at MIN_TIME_BETWEEN_SCANS, care should be taken to
reduce the number of runs to avoid flooding. Slow changing states
should be checked here instead of in spawned components like
media_player since this object is one per account.
Each AlexaAPI call generally results in two webpage requests.
"""
from alexapy import AlexaAPI
email: Text = login_obj.email
if (email not in hass.data[DATA_ALEXAMEDIA]["accounts"]
or "login_successful" not in login_obj.status
or login_obj.session.closed):
return
existing_serials = _existing_serials(hass, login_obj)
existing_entities = hass.data[DATA_ALEXAMEDIA]["accounts"][email][
"entities"]["media_player"].values()
auth_info = hass.data[DATA_ALEXAMEDIA]["accounts"][email].get(
"auth_info")
new_devices = hass.data[DATA_ALEXAMEDIA]["accounts"][email][
"new_devices"]
devices = {}
bluetooth = {}
preferences = {}
dnd = {}
raw_notifications = {}
tasks = [
AlexaAPI.get_devices(login_obj),
AlexaAPI.get_bluetooth(login_obj),
AlexaAPI.get_device_preferences(login_obj),
AlexaAPI.get_dnd_state(login_obj),
AlexaAPI.get_notifications(login_obj),
]
if new_devices:
tasks.append(AlexaAPI.get_authentication(login_obj))
try:
# Note: asyncio.TimeoutError and aiohttp.ClientError are already
# handled by the data update coordinator.
async with async_timeout.timeout(10):
if new_devices:
(
devices,
bluetooth,
preferences,
dnd,
raw_notifications,
auth_info,
) = await asyncio.gather(*tasks)
else:
(
devices,
bluetooth,
preferences,
dnd,
raw_notifications,
) = await asyncio.gather(*tasks)
_LOGGER.debug(
"%s: Found %s devices, %s bluetooth",
hide_email(email),
len(devices) if devices is not None else "",
len(bluetooth.get("bluetoothStates", []))
if bluetooth is not None else "",
)
except (AlexapyLoginError, JSONDecodeError):
_LOGGER.debug(
"%s: Alexa API disconnected; attempting to relogin : status %s",
hide_email(email),
login_obj.status,
)
if login_obj.status:
await login_obj.reset()
await login_obj.login()
await test_login_status(hass, config_entry, login_obj,
setup_alexa)
return
except BaseException as err:
raise
raise UpdateFailed(f"Error communicating with API: {err}")
await process_notifications(login_obj, raw_notifications)
# Process last_called data to fire events
await update_last_called(login_obj)
new_alexa_clients = [] # list of newly discovered device names
exclude_filter = []
include_filter = []
for device in devices:
serial = device["serialNumber"]
dev_name = device["accountName"]
if include and dev_name not in include:
include_filter.append(dev_name)
if "appDeviceList" in device:
for app in device["appDeviceList"]:
(hass.data[DATA_ALEXAMEDIA]["accounts"][email]
["excluded"][app["serialNumber"]]) = device
hass.data[DATA_ALEXAMEDIA]["accounts"][email]["excluded"][
serial] = device
continue
elif exclude and dev_name in exclude:
exclude_filter.append(dev_name)
if "appDeviceList" in device:
for app in device["appDeviceList"]:
(hass.data[DATA_ALEXAMEDIA]["accounts"][email]
["excluded"][app["serialNumber"]]) = device
hass.data[DATA_ALEXAMEDIA]["accounts"][email]["excluded"][
serial] = device
continue
if "bluetoothStates" in bluetooth:
for b_state in bluetooth["bluetoothStates"]:
if serial == b_state["deviceSerialNumber"]:
device["bluetooth_state"] = b_state
break
if "devicePreferences" in preferences:
for dev in preferences["devicePreferences"]:
if dev["deviceSerialNumber"] == serial:
device["locale"] = dev["locale"]
device["timeZoneId"] = dev["timeZoneId"]
_LOGGER.debug(
"%s: Locale %s timezone %s",
dev_name,
device["locale"],
device["timeZoneId"],
)
break
if "doNotDisturbDeviceStatusList" in dnd:
for dev in dnd["doNotDisturbDeviceStatusList"]:
if dev["deviceSerialNumber"] == serial:
device["dnd"] = dev["enabled"]
_LOGGER.debug("%s: DND %s", dev_name, device["dnd"])
hass.data[DATA_ALEXAMEDIA]["accounts"][email][
"devices"]["switch"].setdefault(
serial, {"dnd": True})
break
hass.data[DATA_ALEXAMEDIA]["accounts"][email][
"auth_info"] = device["auth_info"] = auth_info
hass.data[DATA_ALEXAMEDIA]["accounts"][email]["devices"][
"media_player"][serial] = device
if serial not in existing_serials:
new_alexa_clients.append(dev_name)
elif serial in existing_entities:
await hass.data[DATA_ALEXAMEDIA]["accounts"][email][
"entities"]["media_player"].get(serial).refresh(
device, no_api=True)
_LOGGER.debug(
"%s: Existing: %s New: %s;"
" Filtered out by not being in include: %s "
"or in exclude: %s",
hide_email(email),
list(existing_entities),
new_alexa_clients,
include_filter,
exclude_filter,
)
if new_alexa_clients:
cleaned_config = config.copy()
cleaned_config.pop(CONF_PASSWORD, None)
# CONF_PASSWORD contains sensitive info which is no longer needed
for component in ALEXA_COMPONENTS:
_LOGGER.debug("Loading %s", component)
hass.async_add_job(
hass.config_entries.async_forward_entry_setup(
config_entry, component))
hass.data[DATA_ALEXAMEDIA]["accounts"][email]["new_devices"] = False
async def _async_update_data(self) -> dict:
"""Fetch Ruckus Unleashed data."""
try:
return {API_CLIENTS: await self._fetch_clients()}
except (AuthenticationError, ConnectionError) as error:
raise UpdateFailed(error) from error
async def async_update_data():
"""Fetch data from NUT."""
async with async_timeout.timeout(10):
await hass.async_add_executor_job(data.update)
if not data.status:
raise UpdateFailed("Error fetching UPS state")
async def async_update_data():
"""Fetch data from API endpoint."""
try:
return await refresh_subaru_data(entry, vehicle_info, controller)
except SubaruException as err:
raise UpdateFailed(err.message) from err
async def async_get():
try:
return await api.async_get()
except ApiError as err:
raise UpdateFailed(err) from err
async def _async_update_data(self) -> None:
"""Fetch all device and sensor data from api."""
try:
await self.device.async_update()
except FLUX_LED_EXCEPTIONS as ex:
raise UpdateFailed(ex) from ex
async def _async_update_data(self) -> MetWeatherData:
"""Fetch data from Met."""
try:
return await self.weather.fetch_data()
except Exception as err:
raise UpdateFailed(f"Update failed: {err}") from err
async def async_update_data():
"""Get new data from the API."""
try:
return await client.tiles.all()
except TileError as err:
raise UpdateFailed(f"Error while retrieving data: {err}")
