async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
"""Set up motionEye from a config entry."""
hass.data.setdefault(DOMAIN, {})
client = create_motioneye_client(
entry.data[CONF_URL],
admin_username=entry.data.get(CONF_ADMIN_USERNAME),
admin_password=entry.data.get(CONF_ADMIN_PASSWORD),
surveillance_username=entry.data.get(CONF_SURVEILLANCE_USERNAME),
surveillance_password=entry.data.get(CONF_SURVEILLANCE_PASSWORD),
session=async_get_clientsession(hass),
)
try:
await client.async_client_login()
except MotionEyeClientInvalidAuthError as exc:
await client.async_client_close()
raise ConfigEntryAuthFailed from exc
except MotionEyeClientError as exc:
await client.async_client_close()
raise ConfigEntryNotReady from exc
# Ensure every loaded entry has a registered webhook id.
if CONF_WEBHOOK_ID not in entry.data:
hass.config_entries.async_update_entry(
entry, data={
**entry.data, CONF_WEBHOOK_ID: async_generate_id()
})
webhook_register(hass, DOMAIN, "motionEye", entry.data[CONF_WEBHOOK_ID],
handle_webhook)
@callback
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
coordinator = DataUpdateCoordinator(
hass,
_LOGGER,
name=DOMAIN,
update_method=async_update_data,
update_interval=DEFAULT_SCAN_INTERVAL,
)
hass.data[DOMAIN][entry.entry_id] = {
CONF_CLIENT: client,
CONF_COORDINATOR: coordinator,
}
current_cameras: set[tuple[str, str]] = set()
device_registry = await dr.async_get_registry(hass)
@callback
def _async_process_motioneye_cameras() -> None:
"""Process motionEye camera additions and removals."""
inbound_camera: set[tuple[str, str]] = set()
if coordinator.data is None or KEY_CAMERAS not in coordinator.data:
return
for camera in coordinator.data[KEY_CAMERAS]:
if not is_acceptable_camera(camera):
return
camera_id = camera[KEY_ID]
device_identifier = get_motioneye_device_identifier(
entry.entry_id, camera_id)
inbound_camera.add(device_identifier)
if device_identifier in current_cameras:
continue
current_cameras.add(device_identifier)
_add_camera(
hass,
device_registry,
client,
entry,
camera_id,
camera,
device_identifier,
)
# Ensure every device associated with this config entry is still in the
# list of motionEye cameras, otherwise remove the device (and thus
# entities).
for device_entry in dr.async_entries_for_config_entry(
device_registry, entry.entry_id):
for identifier in device_entry.identifiers:
if identifier in inbound_camera:
break
else:
device_registry.async_remove_device(device_entry.id)
async def setup_then_listen() -> None:
await asyncio.gather(
*(hass.config_entries.async_forward_entry_setup(entry, platform)
for platform in PLATFORMS))
entry.async_on_unload(
coordinator.async_add_listener(_async_process_motioneye_cameras))
await coordinator.async_refresh()
entry.async_on_unload(entry.add_update_listener(_async_entry_updated))
hass.async_create_task(setup_then_listen())
return True
async def async_setup_entry(hass, config_entry, async_add_entities):
"""Set up the Hue lights from a config entry."""
bridge: HueBridge = hass.data[HUE_DOMAIN][config_entry.entry_id]
api_version = tuple(int(v) for v in bridge.api.config.apiversion.split("."))
rooms = {}
allow_groups = config_entry.options.get(
CONF_ALLOW_HUE_GROUPS, DEFAULT_ALLOW_HUE_GROUPS
)
supports_groups = api_version >= GROUP_MIN_API_VERSION
if allow_groups and not supports_groups:
LOGGER.warning("Please update your Hue bridge to support groups")
light_coordinator = DataUpdateCoordinator(
hass,
LOGGER,
name="light",
update_method=partial(async_safe_fetch, bridge, bridge.api.lights.update),
update_interval=SCAN_INTERVAL,
request_refresh_debouncer=Debouncer(
bridge.hass, LOGGER, cooldown=REQUEST_REFRESH_DELAY, immediate=True
),
)
# First do a refresh to see if we can reach the hub.
# Otherwise we will declare not ready.
await light_coordinator.async_refresh()
if not light_coordinator.last_update_success:
raise PlatformNotReady
if not supports_groups:
update_lights_without_group_support = partial(
async_update_items,
bridge,
bridge.api.lights,
{},
async_add_entities,
partial(create_light, HueLight, light_coordinator, bridge, False, rooms),
None,
)
# We add a listener after fetching the data, so manually trigger listener
bridge.reset_jobs.append(
light_coordinator.async_add_listener(update_lights_without_group_support)
)
return
group_coordinator = DataUpdateCoordinator(
hass,
LOGGER,
name="group",
update_method=partial(async_safe_fetch, bridge, bridge.api.groups.update),
update_interval=SCAN_INTERVAL,
request_refresh_debouncer=Debouncer(
bridge.hass, LOGGER, cooldown=REQUEST_REFRESH_DELAY, immediate=True
),
)
if allow_groups:
update_groups = partial(
async_update_items,
bridge,
bridge.api.groups,
{},
async_add_entities,
partial(create_light, HueLight, group_coordinator, bridge, True, None),
None,
)
bridge.reset_jobs.append(group_coordinator.async_add_listener(update_groups))
cancel_update_rooms_listener = None
@callback
def _async_update_rooms():
"""Update rooms."""
nonlocal cancel_update_rooms_listener
rooms.clear()
for item_id in bridge.api.groups:
group = bridge.api.groups[item_id]
if group.type not in [GROUP_TYPE_ROOM, GROUP_TYPE_ZONE]:
continue
for light_id in group.lights:
rooms[light_id] = group.name
# Once we do a rooms update, we cancel the listener
# until the next time lights are added
bridge.reset_jobs.remove(cancel_update_rooms_listener)
cancel_update_rooms_listener() # pylint: disable=not-callable
cancel_update_rooms_listener = None
@callback
def _setup_rooms_listener():
nonlocal cancel_update_rooms_listener
if cancel_update_rooms_listener is not None:
# If there are new lights added before _async_update_rooms
# is called we should not add another listener
return
cancel_update_rooms_listener = group_coordinator.async_add_listener(
_async_update_rooms
)
bridge.reset_jobs.append(cancel_update_rooms_listener)
_setup_rooms_listener()
await group_coordinator.async_refresh()
update_lights_with_group_support = partial(
async_update_items,
bridge,
bridge.api.lights,
{},
async_add_entities,
partial(create_light, HueLight, light_coordinator, bridge, False, rooms),
_setup_rooms_listener,
)
# We add a listener after fetching the data, so manually trigger listener
bridge.reset_jobs.append(
light_coordinator.async_add_listener(update_lights_with_group_support)
)
update_lights_with_group_support()
async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
"""Set up Weatherbit forecast as config entry."""
if not entry.options:
hass.config_entries.async_update_entry(
entry,
options={
"fcs_update_interval": entry.data[CONF_FCS_UPDATE_INTERVAL],
"cur_update_interval": entry.data[CONF_CUR_UPDATE_INTERVAL],
"fcst_language": entry.data[CONF_FORECAST_LANGUAGE],
"wind_unit": entry.data.get(CONF_WIND_UNITS, UNIT_WIND_MS),
},
)
session = aiohttp_client.async_get_clientsession(hass)
weatherbit = Weatherbit(
entry.data[CONF_API_KEY],
entry.data[CONF_LATITUDE],
entry.data[CONF_LONGITUDE],
entry.options.get(CONF_FORECAST_LANGUAGE, DEFAULT_FORECAST_LANGUAGE),
"M",
session,
)
hass.data.setdefault(DOMAIN, {})[entry.entry_id] = weatherbit
_LOGGER.debug("Connected to Weatherbit")
if entry.options.get(CONF_FCS_UPDATE_INTERVAL):
fcst_scan_interval = timedelta(minutes=entry.options[CONF_FCS_UPDATE_INTERVAL])
else:
fcst_scan_interval = SCAN_INTERVAL
fcst_coordinator = DataUpdateCoordinator(
hass,
_LOGGER,
name=DOMAIN,
update_method=weatherbit.async_get_forecast_daily,
update_interval=fcst_scan_interval,
)
if entry.data.get(CONF_ADD_ALERTS):
alert_coordinator = DataUpdateCoordinator(
hass,
_LOGGER,
name=DOMAIN,
update_method=weatherbit.async_get_weather_alerts,
update_interval=fcst_scan_interval,
)
else:
alert_coordinator = None
if entry.options.get(CONF_CUR_UPDATE_INTERVAL):
current_scan_interval = timedelta(
minutes=entry.options[CONF_CUR_UPDATE_INTERVAL]
)
else:
current_scan_interval = SCAN_INTERVAL
cur_coordinator = DataUpdateCoordinator(
hass,
_LOGGER,
name=DOMAIN,
update_method=weatherbit.async_get_current_data,
update_interval=current_scan_interval,
)
try:
await weatherbit.async_get_city_name()
except InvalidApiKey:
_LOGGER.error("Your API Key is invalid or does not support this operation")
return False
except (RequestError, ServerDisconnectedError) as err:
_LOGGER.warning(str(err))
raise ConfigEntryNotReady
await fcst_coordinator.async_refresh()
await cur_coordinator.async_refresh()
if entry.data.get(CONF_ADD_ALERTS):
await alert_coordinator.async_refresh()
hass.data[DOMAIN][entry.entry_id] = {
"fcst_coordinator": fcst_coordinator,
"cur_coordinator": cur_coordinator,
"alert_coordinator": alert_coordinator,
"weatherbit": weatherbit,
"wind_unit_metric": entry.options.get(CONF_WIND_UNITS, UNIT_WIND_MS),
}
await _async_get_or_create_weatherbit_device_in_registry(hass, entry)
for platform in WEATHERBIT_PLATFORMS:
hass.async_create_task(
hass.config_entries.async_forward_entry_setup(entry, platform)
)
if not entry.update_listeners:
entry.add_update_listener(async_update_options)
return True
async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
"""Set up the Goodwe components from a config entry."""
hass.data.setdefault(DOMAIN, {})
name = entry.title
host = entry.data[CONF_HOST]
model_family = entry.data[CONF_MODEL_FAMILY]
# Connect to Goodwe inverter
try:
inverter = await connect(
host=host,
family=model_family,
retries=10,
)
except InverterError as err:
raise ConfigEntryNotReady from err
device_info = DeviceInfo(
configuration_url="https://www.semsportal.com",
identifiers={(DOMAIN, inverter.serial_number)},
name=entry.title,
manufacturer="GoodWe",
model=inverter.model_name,
sw_version=f"{inverter.software_version} ({inverter.arm_version})",
)
async def async_update_data():
"""Fetch data from the inverter."""
try:
return await inverter.read_runtime_data()
except RequestFailedException as ex:
# UDP communication with inverter is by definition unreliable.
# It is rather normal in many environments to fail to receive
# proper response in usual time, so we intentionally ignore isolated
# failures and report problem with availability only after
# consecutive streak of 3 of failed requests.
if ex.consecutive_failures_count < 3:
_LOGGER.debug(
"No response received (streak of %d)", ex.consecutive_failures_count
)
# return empty dictionary, sensors will keep their previous values
return {}
# Inverter does not respond anymore (e.g. it went to sleep mode)
_LOGGER.debug(
"Inverter not responding (streak of %d)", ex.consecutive_failures_count
)
raise UpdateFailed(ex) from ex
except InverterError as ex:
raise UpdateFailed(ex) from ex
# Create update coordinator
coordinator = DataUpdateCoordinator(
hass,
_LOGGER,
name=name,
update_method=async_update_data,
# Polling interval. Will only be polled if there are subscribers.
update_interval=SCAN_INTERVAL,
)
# Fetch initial data so we have data when entities subscribe
await coordinator.async_config_entry_first_refresh()
hass.data[DOMAIN][entry.entry_id] = {
KEY_INVERTER: inverter,
KEY_COORDINATOR: coordinator,
KEY_DEVICE_INFO: device_info,
}
entry.async_on_unload(entry.add_update_listener(update_listener))
await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
return True
async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
"""Set up Sense from a config entry."""
entry_data = entry.data
email = entry_data[CONF_EMAIL]
password = entry_data[CONF_PASSWORD]
timeout = entry_data[CONF_TIMEOUT]
client_session = async_get_clientsession(hass)
gateway = ASyncSenseable(api_timeout=timeout,
wss_timeout=timeout,
client_session=client_session)
gateway.rate_limit = ACTIVE_UPDATE_RATE
try:
await gateway.authenticate(email, password)
except SenseAuthenticationException:
_LOGGER.error("Could not authenticate with sense server")
return False
except SENSE_TIMEOUT_EXCEPTIONS as err:
raise ConfigEntryNotReady(
str(err) or "Timed out during authentication") from err
except SENSE_EXCEPTIONS as err:
raise ConfigEntryNotReady(str(err)
or "Error during authentication") from err
sense_devices_data = SenseDevicesData()
try:
sense_discovered_devices = await gateway.get_discovered_device_data()
await gateway.update_realtime()
except SENSE_TIMEOUT_EXCEPTIONS as err:
raise ConfigEntryNotReady(
str(err) or "Timed out during realtime update") from err
except SENSE_EXCEPTIONS as err:
raise ConfigEntryNotReady(str(err)
or "Error during realtime update") from err
trends_coordinator = DataUpdateCoordinator(
hass,
_LOGGER,
name=f"Sense Trends {email}",
update_method=gateway.update_trend_data,
update_interval=timedelta(seconds=300),
)
# Start out as unavailable so we do not report 0 data
# until the update happens
trends_coordinator.last_update_success = False
# This can take longer than 60s and we already know
# sense is online since get_discovered_device_data was
# successful so we do it later.
asyncio.create_task(trends_coordinator.async_request_refresh())
hass.data.setdefault(DOMAIN, {})[entry.entry_id] = {
SENSE_DATA: gateway,
SENSE_DEVICES_DATA: sense_devices_data,
SENSE_TRENDS_COORDINATOR: trends_coordinator,
SENSE_DISCOVERED_DEVICES_DATA: sense_discovered_devices,
}
hass.config_entries.async_setup_platforms(entry, PLATFORMS)
async def async_sense_update(_):
"""Retrieve latest state."""
try:
await gateway.update_realtime()
except SENSE_TIMEOUT_EXCEPTIONS as ex:
_LOGGER.error("Timeout retrieving data: %s", ex)
except SENSE_EXCEPTIONS as ex:
_LOGGER.error("Failed to update data: %s", ex)
data = gateway.get_realtime()
if "devices" in data:
sense_devices_data.set_devices_data(data["devices"])
async_dispatcher_send(
hass, f"{SENSE_DEVICE_UPDATE}-{gateway.sense_monitor_id}")
remove_update_callback = async_track_time_interval(
hass, async_sense_update, timedelta(seconds=ACTIVE_UPDATE_RATE))
@callback
def _remove_update_callback_at_stop(event):
remove_update_callback()
entry.async_on_unload(remove_update_callback)
entry.async_on_unload(
hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP,
_remove_update_callback_at_stop))
return True
async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
"""Set up Synology DSM sensors."""
# Migrate device indentifiers
dev_reg = await get_dev_reg(hass)
devices: list[
DeviceEntry] = device_registry.async_entries_for_config_entry(
dev_reg, entry.entry_id)
for device in devices:
old_identifier = list(next(iter(device.identifiers)))
if len(old_identifier) > 2:
new_identifier = {(old_identifier.pop(0),
"_".join([str(x) for x in old_identifier]))}
_LOGGER.debug("migrate identifier '%s' to '%s'",
device.identifiers, new_identifier)
dev_reg.async_update_device(device.id,
new_identifiers=new_identifier)
# Migrate existing entry configuration
if entry.data.get(CONF_VERIFY_SSL) is None:
hass.config_entries.async_update_entry(
entry, data={
**entry.data, CONF_VERIFY_SSL: DEFAULT_VERIFY_SSL
})
# Continue setup
api = SynoApi(hass, entry)
try:
await api.async_setup()
except (
SynologyDSMLogin2SARequiredException,
SynologyDSMLoginDisabledAccountException,
SynologyDSMLoginInvalidException,
SynologyDSMLoginPermissionDeniedException,
) as err:
if err.args[0] and isinstance(err.args[0], dict):
# pylint: disable=no-member
details = err.args[0].get(EXCEPTION_DETAILS, EXCEPTION_UNKNOWN)
else:
details = EXCEPTION_UNKNOWN
raise ConfigEntryAuthFailed(f"reason: {details}") from err
except (SynologyDSMLoginFailedException,
SynologyDSMRequestException) as err:
if err.args[0] and isinstance(err.args[0], dict):
# pylint: disable=no-member
details = err.args[0].get(EXCEPTION_DETAILS, EXCEPTION_UNKNOWN)
else:
details = EXCEPTION_UNKNOWN
raise ConfigEntryNotReady(details) from err
hass.data.setdefault(DOMAIN, {})
hass.data[DOMAIN][entry.unique_id] = {
UNDO_UPDATE_LISTENER:
entry.add_update_listener(_async_update_listener),
SYNO_API: api,
SYSTEM_LOADED: True,
}
# Services
await async_setup_services(hass)
# For SSDP compat
if not entry.data.get(CONF_MAC):
network = await hass.async_add_executor_job(getattr, api.dsm,
"network")
hass.config_entries.async_update_entry(entry,
data={
**entry.data, CONF_MAC:
network.macs
})
async def async_coordinator_update_data_cameras(
) -> dict[str, dict[str, SynoCamera]] | None:
"""Fetch all camera data from api."""
if not hass.data[DOMAIN][entry.unique_id][SYSTEM_LOADED]:
raise UpdateFailed("System not fully loaded")
if SynoSurveillanceStation.CAMERA_API_KEY not in api.dsm.apis:
return None
surveillance_station = api.surveillance_station
try:
async with async_timeout.timeout(30):
await hass.async_add_executor_job(surveillance_station.update)
except SynologyDSMAPIErrorException as err:
raise UpdateFailed(f"Error communicating with API: {err}") from err
return {
"cameras": {
camera.id: camera
for camera in surveillance_station.get_all_cameras()
}
}
async def async_coordinator_update_data_central() -> None:
"""Fetch all device and sensor data from api."""
try:
await api.async_update()
except Exception as err:
raise UpdateFailed(f"Error communicating with API: {err}") from err
return None
async def async_coordinator_update_data_switches(
) -> dict[str, dict[str, Any]] | None:
"""Fetch all switch data from api."""
if not hass.data[DOMAIN][entry.unique_id][SYSTEM_LOADED]:
raise UpdateFailed("System not fully loaded")
if SynoSurveillanceStation.HOME_MODE_API_KEY not in api.dsm.apis:
return None
surveillance_station = api.surveillance_station
return {
"switches": {
"home_mode":
await hass.async_add_executor_job(
surveillance_station.get_home_mode_status)
}
}
hass.data[DOMAIN][
entry.unique_id][COORDINATOR_CAMERAS] = DataUpdateCoordinator(
hass,
_LOGGER,
name=f"{entry.unique_id}_cameras",
update_method=async_coordinator_update_data_cameras,
update_interval=timedelta(seconds=30),
)
hass.data[DOMAIN][
entry.unique_id][COORDINATOR_CENTRAL] = DataUpdateCoordinator(
hass,
_LOGGER,
name=f"{entry.unique_id}_central",
update_method=async_coordinator_update_data_central,
update_interval=timedelta(minutes=entry.options.get(
CONF_SCAN_INTERVAL, DEFAULT_SCAN_INTERVAL)),
)
hass.data[DOMAIN][
entry.unique_id][COORDINATOR_SWITCHES] = DataUpdateCoordinator(
hass,
_LOGGER,
name=f"{entry.unique_id}_switches",
update_method=async_coordinator_update_data_switches,
update_interval=timedelta(seconds=30),
)
hass.config_entries.async_setup_platforms(entry, PLATFORMS)
return True
async def async_setup_platform(hass, config, async_add_entities, discovery_info=None):
"""Connect to the uHoo API and find devices."""
from pyuhoo import Client
from aiohttp import ClientSession
# from pyuhoo.data import get_all_devices
# from pyuhoo.objects import UhooDev
username = config[CONF_EMAIL]
password = config[CONF_PASSWORD]
async with ClientSession() as websession:
client = Client(username, password, websession, debug=True)
try:
await client.login()
await client.get_latest_data()
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.
"""
try:
# Note: asyncio.TimeoutError and aiohttp.ClientError are already
# handled by the data update coordinator.
async with async_timeout.timeout(10):
return await client.get_latest_data()
except Exception as err:
raise UpdateFailed(f"Error communicating with API: {err}")
coordinator = DataUpdateCoordinator(
hass,
_LOGGER,
# Name of the data. For logging purposes.
name="uHoo",
update_method=async_update_data,
# Polling interval. Will only be polled if there are subscribers.
update_interval=timedelta(seconds=5 * 60),
)
# Fetch initial data so we have data when entities subscribe
await coordinator.async_refresh()
all_devices = []
devices = client.get_devices()
for device in devices.values():
_LOGGER.debug(
f"Found: {device.serial_number}\n {device.datetime}\n "
+ f"{device.temp} {client.user_settings_temp}\n"
)
for sensor in SENSOR_TYPES:
if hasattr(device, sensor):
uhoo_sensor = UhooAirSensor(coordinator, device, sensor)
all_devices.append(uhoo_sensor)
async_add_entities(all_devices, True)
return
except Exception as e:
_LOGGER.error("Error: {0}".format(e))
raise PlatformNotReady
async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry):
"""Set up Tesla Powerwall from a config entry."""
entry_id = entry.entry_id
hass.data[DOMAIN].setdefault(entry_id, {})
http_session = requests.Session()
power_wall = Powerwall(entry.data[CONF_IP_ADDRESS],
http_session=http_session)
try:
await hass.async_add_executor_job(power_wall.detect_and_pin_version)
await hass.async_add_executor_job(_fetch_powerwall_data, power_wall)
powerwall_data = await hass.async_add_executor_job(
call_base_info, power_wall)
except PowerwallUnreachableError as err:
http_session.close()
raise ConfigEntryNotReady from err
except MissingAttributeError as err:
http_session.close()
await _async_handle_api_changed_error(hass, err)
return False
await _migrate_old_unique_ids(hass, entry_id, powerwall_data)
async def async_update_data():
"""Fetch data from API endpoint."""
# Check if we had an error before
_LOGGER.debug("Checking if update failed")
if not hass.data[DOMAIN][entry.entry_id][POWERWALL_API_CHANGED]:
_LOGGER.debug("Updating data")
try:
return await hass.async_add_executor_job(
_fetch_powerwall_data, power_wall)
except PowerwallUnreachableError as err:
raise UpdateFailed(
"Unable to fetch data from powerwall") from err
except MissingAttributeError as err:
await _async_handle_api_changed_error(hass, err)
hass.data[DOMAIN][entry.entry_id][POWERWALL_API_CHANGED] = True
# Returns the cached data. This data can also be None
return hass.data[DOMAIN][
entry.entry_id][POWERWALL_COORDINATOR].data
else:
return hass.data[DOMAIN][
entry.entry_id][POWERWALL_COORDINATOR].data
coordinator = DataUpdateCoordinator(
hass,
_LOGGER,
name="Powerwall site",
update_method=async_update_data,
update_interval=timedelta(seconds=UPDATE_INTERVAL),
)
hass.data[DOMAIN][entry.entry_id] = powerwall_data
hass.data[DOMAIN][entry.entry_id].update({
POWERWALL_OBJECT: power_wall,
POWERWALL_COORDINATOR: coordinator,
POWERWALL_HTTP_SESSION: http_session,
POWERWALL_API_CHANGED: False,
})
await coordinator.async_refresh()
for component in PLATFORMS:
hass.async_create_task(
hass.config_entries.async_forward_entry_setup(entry, component))
return True
async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
"""Set up Notion as a config entry."""
if not entry.unique_id:
hass.config_entries.async_update_entry(
entry, unique_id=entry.data[CONF_USERNAME])
session = aiohttp_client.async_get_clientsession(hass)
try:
client = await async_get_client(entry.data[CONF_USERNAME],
entry.data[CONF_PASSWORD], session)
except InvalidCredentialsError:
_LOGGER.error("Invalid username and/or password")
return False
except NotionError as err:
_LOGGER.error("Config entry failed: %s", err)
raise ConfigEntryNotReady from err
async def async_update():
"""Get the latest data from the Notion API."""
data = {"bridges": {}, "sensors": {}, "tasks": {}}
tasks = {
"bridges": client.bridge.async_all(),
"sensors": client.sensor.async_all(),
"tasks": client.task.async_all(),
}
results = await asyncio.gather(*tasks.values(), return_exceptions=True)
for attr, result in zip(tasks, results):
if isinstance(result, NotionError):
raise UpdateFailed(
f"There was a Notion error while updating {attr}: {result}"
)
if isinstance(result, Exception):
raise UpdateFailed(
f"There was an unknown error while updating {attr}: {result}"
)
for item in result:
if attr == "bridges" and item["id"] not in data["bridges"]:
# If a new bridge is discovered, register it:
hass.async_create_task(
async_register_new_bridge(hass, item, entry))
data[attr][item["id"]] = item
return data
coordinator = hass.data[DOMAIN][DATA_COORDINATOR][
entry.entry_id] = DataUpdateCoordinator(
hass,
_LOGGER,
name=entry.data[CONF_USERNAME],
update_interval=DEFAULT_SCAN_INTERVAL,
update_method=async_update,
)
await coordinator.async_refresh()
for platform in PLATFORMS:
hass.async_create_task(
hass.config_entries.async_forward_entry_setup(entry, platform))
return True
async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
"""Set up RainMachine as config entry."""
websession = aiohttp_client.async_get_clientsession(hass)
client = Client(session=websession)
try:
await client.load_local(
entry.data[CONF_IP_ADDRESS],
entry.data[CONF_PASSWORD],
port=entry.data[CONF_PORT],
ssl=entry.data.get(CONF_SSL, DEFAULT_SSL),
)
except RainMachineError as err:
raise ConfigEntryNotReady from err
# regenmaschine can load multiple controllers at once, but we only grab the one
# we loaded above:
controller = get_client_controller(client)
entry_updates: dict[str, Any] = {}
if not entry.unique_id or is_ip_address(entry.unique_id):
# If the config entry doesn't already have a unique ID, set one:
entry_updates["unique_id"] = controller.mac
if CONF_ZONE_RUN_TIME in entry.data:
# If a zone run time exists in the config entry's data, pop it and move it to
# options:
data = {**entry.data}
entry_updates["data"] = data
entry_updates["options"] = {
**entry.options,
CONF_ZONE_RUN_TIME: data.pop(CONF_ZONE_RUN_TIME),
}
if entry_updates:
hass.config_entries.async_update_entry(entry, **entry_updates)
async def async_update(api_category: str) -> dict:
"""Update the appropriate API data based on a category."""
data: dict = {}
try:
if api_category == DATA_PROGRAMS:
data = await controller.programs.all(include_inactive=True)
elif api_category == DATA_PROVISION_SETTINGS:
data = await controller.provisioning.settings()
elif api_category == DATA_RESTRICTIONS_CURRENT:
data = await controller.restrictions.current()
elif api_category == DATA_RESTRICTIONS_UNIVERSAL:
data = await controller.restrictions.universal()
else:
data = await controller.zones.all(details=True,
include_inactive=True)
except RainMachineError as err:
raise UpdateFailed(err) from err
return data
controller_init_tasks = []
coordinators = {}
for api_category in (
DATA_PROGRAMS,
DATA_PROVISION_SETTINGS,
DATA_RESTRICTIONS_CURRENT,
DATA_RESTRICTIONS_UNIVERSAL,
DATA_ZONES,
):
coordinator = coordinators[api_category] = DataUpdateCoordinator(
hass,
LOGGER,
name=f'{controller.name} ("{api_category}")',
update_interval=UPDATE_INTERVALS[api_category],
update_method=partial(async_update, api_category),
)
controller_init_tasks.append(coordinator.async_refresh())
await asyncio.gather(*controller_init_tasks)
hass.data.setdefault(DOMAIN, {})
hass.data[DOMAIN][entry.entry_id] = {
DATA_CONTROLLER: controller,
DATA_COORDINATOR: coordinators,
}
hass.config_entries.async_setup_platforms(entry, PLATFORMS)
entry.async_on_unload(entry.add_update_listener(async_reload_entry))
async def async_pause_watering(call: ServiceCall) -> None:
"""Pause watering for a set number of seconds."""
controller = async_get_controller_for_service_call(hass, call)
await controller.watering.pause_all(call.data[CONF_SECONDS])
await async_update_programs_and_zones(hass, entry)
async def async_push_weather_data(call: ServiceCall) -> None:
"""Push weather data to the device."""
controller = async_get_controller_for_service_call(hass, call)
await controller.parsers.post_data({
CONF_WEATHER: [{
key: value
for key, value in call.data.items() if key != CONF_DEVICE_ID
}]
})
async def async_stop_all(call: ServiceCall) -> None:
"""Stop all watering."""
controller = async_get_controller_for_service_call(hass, call)
await controller.watering.stop_all()
await async_update_programs_and_zones(hass, entry)
async def async_unpause_watering(call: ServiceCall) -> None:
"""Unpause watering."""
controller = async_get_controller_for_service_call(hass, call)
await controller.watering.unpause_all()
await async_update_programs_and_zones(hass, entry)
for service_name, schema, method in (
(
SERVICE_NAME_PAUSE_WATERING,
SERVICE_PAUSE_WATERING_SCHEMA,
async_pause_watering,
),
(
SERVICE_NAME_PUSH_WEATHER_DATA,
SERVICE_PUSH_WEATHER_DATA_SCHEMA,
async_push_weather_data,
),
(SERVICE_NAME_STOP_ALL, SERVICE_SCHEMA, async_stop_all),
(SERVICE_NAME_UNPAUSE_WATERING, SERVICE_SCHEMA,
async_unpause_watering),
):
if hass.services.has_service(DOMAIN, service_name):
continue
hass.services.async_register(DOMAIN,
service_name,
method,
schema=schema)
return True
async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
"""Set up devolo Home Network from a config entry."""
hass.data.setdefault(DOMAIN, {})
zeroconf_instance = await zeroconf.async_get_async_instance(hass)
async_client = get_async_client(hass)
try:
device = Device(ip=entry.data[CONF_IP_ADDRESS],
zeroconf_instance=zeroconf_instance)
await device.async_connect(session_instance=async_client)
except DeviceNotFound as err:
raise ConfigEntryNotReady(
f"Unable to connect to {entry.data[CONF_IP_ADDRESS]}") from err
async def async_update_connected_plc_devices() -> dict[str, Any]:
"""Fetch data from API endpoint."""
try:
async with async_timeout.timeout(10):
return await device.plcnet.async_get_network_overview(
) # type: ignore[no-any-return, union-attr]
except DeviceUnavailable as err:
raise UpdateFailed(err) from err
async def async_update_wifi_connected_station() -> dict[str, Any]:
"""Fetch data from API endpoint."""
try:
async with async_timeout.timeout(10):
return await device.device.async_get_wifi_connected_station(
) # type: ignore[no-any-return, union-attr]
except DeviceUnavailable as err:
raise UpdateFailed(err) from err
async def async_update_wifi_neighbor_access_points() -> dict[str, Any]:
"""Fetch data from API endpoint."""
try:
async with async_timeout.timeout(30):
return await device.device.async_get_wifi_neighbor_access_points(
) # type: ignore[no-any-return, union-attr]
except DeviceUnavailable as err:
raise UpdateFailed(err) from err
async def disconnect(event: Event) -> None:
"""Disconnect from device."""
await device.async_disconnect()
coordinators: dict[str, DataUpdateCoordinator] = {}
if device.plcnet:
coordinators[CONNECTED_PLC_DEVICES] = DataUpdateCoordinator(
hass,
_LOGGER,
name=CONNECTED_PLC_DEVICES,
update_method=async_update_connected_plc_devices,
update_interval=LONG_UPDATE_INTERVAL,
)
if device.device and "wifi1" in device.device.features:
coordinators[CONNECTED_WIFI_CLIENTS] = DataUpdateCoordinator(
hass,
_LOGGER,
name=CONNECTED_WIFI_CLIENTS,
update_method=async_update_wifi_connected_station,
update_interval=SHORT_UPDATE_INTERVAL,
)
coordinators[NEIGHBORING_WIFI_NETWORKS] = DataUpdateCoordinator(
hass,
_LOGGER,
name=NEIGHBORING_WIFI_NETWORKS,
update_method=async_update_wifi_neighbor_access_points,
update_interval=LONG_UPDATE_INTERVAL,
)
hass.data[DOMAIN][entry.entry_id] = {
"device": device,
"coordinators": coordinators
}
for coordinator in coordinators.values():
await coordinator.async_config_entry_first_refresh()
hass.config_entries.async_setup_platforms(entry, PLATFORMS)
entry.async_on_unload(
hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, disconnect))
return True
async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
"""Set up Enphase Envoy from a config entry."""
config = entry.data
name = config[CONF_NAME]
envoy_reader = EnvoyReader(
config[CONF_HOST],
config[CONF_USERNAME],
config[CONF_PASSWORD],
inverters=True,
async_client=get_async_client(hass),
)
async def async_update_data():
"""Fetch data from API endpoint."""
data = {}
async with async_timeout.timeout(30):
try:
await envoy_reader.getData()
except httpx.HTTPStatusError as err:
raise ConfigEntryAuthFailed from err
except httpx.HTTPError as err:
raise UpdateFailed(
f"Error communicating with API: {err}") from err
for description in SENSORS:
if description.key != "inverters":
data[description.key] = await getattr(
envoy_reader, description.key)()
else:
data[
"inverters_production"] = await envoy_reader.inverters_production(
)
_LOGGER.debug("Retrieved data from API: %s", data)
return data
coordinator = DataUpdateCoordinator(
hass,
_LOGGER,
name=f"envoy {name}",
update_method=async_update_data,
update_interval=SCAN_INTERVAL,
)
try:
await coordinator.async_config_entry_first_refresh()
except ConfigEntryAuthFailed:
envoy_reader.get_inverters = False
await coordinator.async_config_entry_first_refresh()
hass.data.setdefault(DOMAIN, {})[entry.entry_id] = {
COORDINATOR: coordinator,
NAME: name,
}
hass.config_entries.async_setup_platforms(entry, PLATFORMS)
return True
async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
"""Set up Hunter Douglas PowerView from a config entry."""
config = entry.data
hub_address = config.get(CONF_HOST)
websession = async_get_clientsession(hass)
pv_request = AioRequest(hub_address, loop=hass.loop, websession=websession)
try:
async with async_timeout.timeout(10):
device_info = await async_get_device_info(pv_request)
async with async_timeout.timeout(10):
rooms = Rooms(pv_request)
room_data = _async_map_data_by_id(
(await rooms.get_resources())[ROOM_DATA])
async with async_timeout.timeout(10):
scenes = Scenes(pv_request)
scene_data = _async_map_data_by_id(
(await scenes.get_resources())[SCENE_DATA])
async with async_timeout.timeout(10):
shades = Shades(pv_request)
shade_data = _async_map_data_by_id(
(await shades.get_resources())[SHADE_DATA])
except HUB_EXCEPTIONS as err:
_LOGGER.error("Connection error to PowerView hub: %s", hub_address)
raise ConfigEntryNotReady from err
if not device_info:
_LOGGER.error("Unable to initialize PowerView hub: %s", hub_address)
raise ConfigEntryNotReady
async def async_update_data():
"""Fetch data from shade endpoint."""
async with async_timeout.timeout(10):
shade_entries = await shades.get_resources()
if not shade_entries:
raise UpdateFailed("Failed to fetch new shade data.")
return _async_map_data_by_id(shade_entries[SHADE_DATA])
coordinator = DataUpdateCoordinator(
hass,
_LOGGER,
name="powerview hub",
update_method=async_update_data,
update_interval=timedelta(seconds=60),
)
hass.data.setdefault(DOMAIN, {})
hass.data[DOMAIN][entry.entry_id] = {
PV_API: pv_request,
PV_ROOM_DATA: room_data,
PV_SCENE_DATA: scene_data,
PV_SHADES: shades,
PV_SHADE_DATA: shade_data,
COORDINATOR: coordinator,
DEVICE_INFO: device_info,
}
hass.config_entries.async_setup_platforms(entry, PLATFORMS)
return True
async def async_setup_entry(hass: HomeAssistantType, entry: ConfigEntry) -> bool:
"""Set up SmartWeather platforms as config entry."""
if not entry.options:
hass.config_entries.async_update_entry(
entry,
options={
CONF_ADD_SENSORS: entry.data.get(CONF_ADD_SENSORS, True),
CONF_WIND_UNIT: entry.data.get(CONF_WIND_UNIT, UNIT_WIND_MS),
CONF_SCAN_INTERVAL: entry.data.get(
CONF_SCAN_INTERVAL, DEFAULT_SCAN_INTERVAL
),
CONF_FORECAST_INTERVAL: entry.data.get(
CONF_FORECAST_INTERVAL, DEFAULT_FORECAST_INTERVAL
),
CONF_FORECAST_TYPE: entry.data.get(
CONF_FORECAST_TYPE, FORECAST_TYPE_DAILY
),
},
)
unit_system = "metric" if hass.config.units.is_metric else "imperial"
session = async_get_clientsession(hass)
smartweather = SmartWeather(
entry.data[CONF_API_KEY],
entry.data[CONF_STATION_ID],
unit_system,
entry.options[CONF_WIND_UNIT],
session,
)
_LOGGER.debug("Connected to SmartWeather Platform")
hass.data.setdefault(DOMAIN, {})[entry.entry_id] = smartweather
coordinator = DataUpdateCoordinator(
hass,
_LOGGER,
name=DOMAIN,
update_method=smartweather.get_station_data,
update_interval=timedelta(
seconds=entry.options.get(CONF_SCAN_INTERVAL, DEFAULT_SCAN_INTERVAL)
),
)
fcst_type = entry.options.get(CONF_FORECAST_TYPE, FORECAST_TYPE_DAILY)
if fcst_type == FORECAST_TYPE_DAILY:
# Update Forecast with Daily data
fcst_coordinator = DataUpdateCoordinator(
hass,
_LOGGER,
name=DOMAIN,
update_method=smartweather.get_daily_forecast,
update_interval=timedelta(
minutes=entry.options.get(
CONF_FORECAST_INTERVAL, DEFAULT_FORECAST_INTERVAL
)
),
)
else:
# Update Forecast with Hourly data
fcst_coordinator = DataUpdateCoordinator(
hass,
_LOGGER,
name=DOMAIN,
update_method=smartweather.get_hourly_forecast,
update_interval=timedelta(
minutes=entry.options.get(
CONF_FORECAST_INTERVAL, DEFAULT_FORECAST_INTERVAL
)
),
)
try:
station_info = await smartweather.get_station_hardware()
except InvalidApiKey:
_LOGGER.error(
"Could not Authorize against Weatherflow Server. Please reinstall integration."
)
return
except (ResultError, ServerDisconnectedError) as err:
_LOGGER.warning(str(err))
raise ConfigEntryNotReady
except RequestError as err:
_LOGGER.error(f"Error occured: {err}")
return
# Fetch initial data so we have data when entities subscribe
await coordinator.async_refresh()
await fcst_coordinator.async_refresh()
hass.data[DOMAIN][entry.entry_id] = {
"coordinator": coordinator,
"fcst_coordinator": fcst_coordinator,
"smw": smartweather,
"station": station_info,
"fcst_type": fcst_type,
}
await _async_get_or_create_smartweather_device_in_registry(
hass, entry, station_info
)
for platform in SMARTWEATHER_PLATFORMS:
hass.async_create_task(
hass.config_entries.async_forward_entry_setup(entry, platform)
)
if not entry.update_listeners:
entry.add_update_listener(async_update_options)
return True
async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
"""Set up an Meteo-France account from a config entry."""
hass.data.setdefault(DOMAIN, {})
client = MeteoFranceClient()
latitude = entry.data[CONF_LATITUDE]
longitude = entry.data[CONF_LONGITUDE]
async def _async_update_data_forecast_forecast():
"""Fetch data from API endpoint."""
return await hass.async_add_executor_job(
client.get_forecast, latitude, longitude
)
async def _async_update_data_rain():
"""Fetch data from API endpoint."""
return await hass.async_add_executor_job(client.get_rain, latitude, longitude)
async def _async_update_data_alert():
"""Fetch data from API endpoint."""
return await hass.async_add_executor_job(
client.get_warning_current_phenomenoms, department, 0, True
)
coordinator_forecast = DataUpdateCoordinator(
hass,
_LOGGER,
name=f"Météo-France forecast for city {entry.title}",
update_method=_async_update_data_forecast_forecast,
update_interval=SCAN_INTERVAL,
)
coordinator_rain = None
coordinator_alert = None
# Fetch initial data so we have data when entities subscribe
await coordinator_forecast.async_refresh()
if not coordinator_forecast.last_update_success:
raise ConfigEntryNotReady
# Check if rain forecast is available.
if coordinator_forecast.data.position.get("rain_product_available") == 1:
coordinator_rain = DataUpdateCoordinator(
hass,
_LOGGER,
name=f"Météo-France rain for city {entry.title}",
update_method=_async_update_data_rain,
update_interval=SCAN_INTERVAL_RAIN,
)
await coordinator_rain.async_refresh()
if not coordinator_rain.last_update_success:
raise ConfigEntryNotReady
else:
_LOGGER.warning(
"1 hour rain forecast not available. %s is not in covered zone",
entry.title,
)
department = coordinator_forecast.data.position.get("dept")
_LOGGER.debug(
"Department corresponding to %s is %s",
entry.title,
department,
)
if is_valid_warning_department(department):
if not hass.data[DOMAIN].get(department):
coordinator_alert = DataUpdateCoordinator(
hass,
_LOGGER,
name=f"Météo-France alert for department {department}",
update_method=_async_update_data_alert,
update_interval=SCAN_INTERVAL,
)
await coordinator_alert.async_refresh()
if not coordinator_alert.last_update_success:
raise ConfigEntryNotReady
hass.data[DOMAIN][department] = True
else:
_LOGGER.warning(
"Weather alert for department %s won't be added with city %s, as it has already been added within another city",
department,
entry.title,
)
else:
_LOGGER.warning(
"Weather alert not available: The city %s is not in metropolitan France or Andorre",
entry.title,
)
undo_listener = entry.add_update_listener(_async_update_listener)
hass.data[DOMAIN][entry.entry_id] = {
COORDINATOR_FORECAST: coordinator_forecast,
COORDINATOR_RAIN: coordinator_rain,
COORDINATOR_ALERT: coordinator_alert,
UNDO_UPDATE_LISTENER: undo_listener,
}
await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
return True
async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
"""Set up the AVM FRITZ!SmartHome platforms."""
fritz = Fritzhome(
host=entry.data[CONF_HOST],
user=entry.data[CONF_USERNAME],
password=entry.data[CONF_PASSWORD],
)
try:
await hass.async_add_executor_job(fritz.login)
except LoginError as err:
raise ConfigEntryAuthFailed from err
hass.data.setdefault(DOMAIN, {})
hass.data[DOMAIN][entry.entry_id] = {
CONF_CONNECTIONS: fritz,
}
def _update_fritz_devices() -> dict[str, FritzhomeDevice]:
"""Update all fritzbox device data."""
try:
devices = fritz.get_devices()
except requests.exceptions.HTTPError:
# If the device rebooted, login again
try:
fritz.login()
except requests.exceptions.HTTPError as ex:
raise ConfigEntryAuthFailed from ex
devices = fritz.get_devices()
data = {}
for device in devices:
device.update()
data[device.ain] = device
return data
async def async_update_coordinator() -> dict[str, FritzhomeDevice]:
"""Fetch all device data."""
return await hass.async_add_executor_job(_update_fritz_devices)
hass.data[DOMAIN][entry.entry_id][
CONF_COORDINATOR] = coordinator = DataUpdateCoordinator(
hass,
LOGGER,
name=f"{entry.entry_id}",
update_method=async_update_coordinator,
update_interval=timedelta(seconds=30),
)
await coordinator.async_config_entry_first_refresh()
def _update_unique_id(entry: RegistryEntry) -> dict[str, str] | None:
"""Update unique ID of entity entry."""
if (entry.unit_of_measurement == TEMP_CELSIUS
and "_temperature" not in entry.unique_id):
new_unique_id = f"{entry.unique_id}_temperature"
LOGGER.info("Migrating unique_id [%s] to [%s]", entry.unique_id,
new_unique_id)
return {"new_unique_id": new_unique_id}
return None
await async_migrate_entries(hass, entry.entry_id, _update_unique_id)
hass.config_entries.async_setup_platforms(entry, PLATFORMS)
def logout_fritzbox(event: Event) -> None:
"""Close connections to this fritzbox."""
fritz.logout()
entry.async_on_unload(
hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, logout_fritzbox))
return True
