async def async_setup(opp, config): """Try to start embedded Lightwave broker.""" host = config[DOMAIN][CONF_HOST] lwlink = LWLink(host) opp.data[LIGHTWAVE_LINK] = lwlink lights = config[DOMAIN][CONF_LIGHTS] if lights: opp.async_create_task( async_load_platform(opp, "light", DOMAIN, lights, config)) switches = config[DOMAIN][CONF_SWITCHES] if switches: opp.async_create_task( async_load_platform(opp, "switch", DOMAIN, switches, config)) trv = config[DOMAIN][CONF_TRV] if trv: trvs = trv[CONF_TRVS] proxy_ip = trv[CONF_PROXY_IP] proxy_port = trv[CONF_PROXY_PORT] lwlink.set_trv_proxy(proxy_ip, proxy_port) platforms = [CLIMATE_DOMAIN, SENSOR_DOMAIN] for platform in platforms: opp.async_create_task( async_load_platform(opp, platform, DOMAIN, trvs, config)) return True
async def async_setup(opp, config): """Set up an Utility Meter.""" component = EntityComponent(_LOGGER, DOMAIN, opp) opp.data[DATA_UTILITY] = {} register_services = False for meter, conf in config.get(DOMAIN).items(): _LOGGER.debug("Setup %s.%s", DOMAIN, meter) opp.data[DATA_UTILITY][meter] = conf if not conf[CONF_TARIFFS]: # only one entity is required opp.async_create_task( discovery.async_load_platform( opp, SENSOR_DOMAIN, DOMAIN, [{ CONF_METER: meter, CONF_NAME: meter }], config, )) else: # create tariff selection await component.async_add_entities( [TariffSelect(meter, list(conf[CONF_TARIFFS]))]) opp.data[DATA_UTILITY][meter][CONF_TARIFF_ENTITY] = "{}.{}".format( DOMAIN, meter) # add one meter for each tariff tariff_confs = [] for tariff in conf[CONF_TARIFFS]: tariff_confs.append({ CONF_METER: meter, CONF_NAME: f"{meter} {tariff}", CONF_TARIFF: tariff, }) opp.async_create_task( discovery.async_load_platform(opp, SENSOR_DOMAIN, DOMAIN, tariff_confs, config)) register_services = True if register_services: component.async_register_entity_service(SERVICE_RESET, {}, "async_reset_meters") component.async_register_entity_service( SERVICE_SELECT_TARIFF, {vol.Required(ATTR_TARIFF): cv.string}, "async_select_tariff", ) component.async_register_entity_service(SERVICE_SELECT_NEXT_TARIFF, {}, "async_next_tariff") return True
async def add_table(host, name=None): """Add platforms for a single table with the given hostname.""" tables[host] = TableHolder(opp, session, host, name) opp.async_create_task( async_load_platform(opp, "light", DOMAIN, {CONF_HOST: host}, config)) opp.async_create_task( async_load_platform(opp, "media_player", DOMAIN, {CONF_HOST: host}, config))
async def async_setup(opp: OpenPeerPowerType, config: ConfigType): """Set up the mobile app component.""" store = opp.helpers.storage.Store(STORAGE_VERSION, STORAGE_KEY) app_config = await store.async_load() if app_config is None: app_config = { DATA_BINARY_SENSOR: {}, DATA_CONFIG_ENTRIES: {}, DATA_DELETED_IDS: [], DATA_SENSOR: {}, } opp.data[DOMAIN] = { DATA_BINARY_SENSOR: app_config.get(DATA_BINARY_SENSOR, {}), DATA_CONFIG_ENTRIES: {}, DATA_DELETED_IDS: app_config.get(DATA_DELETED_IDS, []), DATA_DEVICES: {}, DATA_SENSOR: app_config.get(DATA_SENSOR, {}), DATA_STORE: store, } opp.http.register_view(RegistrationsView()) for deleted_id in opp.data[DOMAIN][DATA_DELETED_IDS]: try: webhook_register(opp, DOMAIN, "Deleted Webhook", deleted_id, handle_webhook) except ValueError: pass opp.async_create_task( discovery.async_load_platform(opp, "notify", DOMAIN, {}, config) ) return True
async def async_setup(opp, config): """Set the tankerkoenig component up.""" if DOMAIN not in config: return True conf = config[DOMAIN] _LOGGER.debug("Setting up integration") tankerkoenig = TankerkoenigData(opp, conf) latitude = conf.get(CONF_LATITUDE, opp.config.latitude) longitude = conf.get(CONF_LONGITUDE, opp.config.longitude) radius = conf[CONF_RADIUS] additional_stations = conf[CONF_STATIONS] setup_ok = await opp.async_add_executor_job(tankerkoenig.setup, latitude, longitude, radius, additional_stations) if not setup_ok: _LOGGER.error("Could not setup integration") return False opp.data[DOMAIN] = tankerkoenig opp.async_create_task( async_load_platform( opp, SENSOR_DOMAIN, DOMAIN, discovered=tankerkoenig.stations, opp_config=conf, )) return True
async def async_setup(opp, opp_config): """Create an Intergas InComfort/Intouch system.""" incomfort_data = opp.data[DOMAIN] = {} credentials = dict(opp_config[DOMAIN]) hostname = credentials.pop(CONF_HOST) client = incomfort_data["client"] = InComfortGateway( hostname, **credentials, session=async_get_clientsession(opp) ) try: heaters = incomfort_data["heaters"] = list(await client.heaters) except ClientResponseError as err: _LOGGER.warning("Setup failed, check your configuration, message is: %s", err) return False for heater in heaters: await heater.update() for platform in ["water_heater", "binary_sensor", "sensor", "climate"]: opp.async_create_task( async_load_platform(opp, platform, DOMAIN, {}, opp_config) ) return True
async def async_setup(opp: OpenPeerPower, config: ConfigType) -> bool: """Create a Genius Hub system.""" opp.data[DOMAIN] = {} kwargs = dict(config[DOMAIN]) if CONF_HOST in kwargs: args = (kwargs.pop(CONF_HOST),) else: args = (kwargs.pop(CONF_TOKEN),) hub_uid = kwargs.pop(CONF_MAC, None) client = GeniusHub(*args, **kwargs, session=async_get_clientsession(opp)) broker = opp.data[DOMAIN]["broker"] = GeniusBroker(opp, client, hub_uid) try: await client.update() except aiohttp.ClientResponseError as err: _LOGGER.error("Setup failed, check your configuration, %s", err) return False broker.make_debug_log_entries() async_track_time_interval(opp, broker.async_update, SCAN_INTERVAL) for platform in ["climate", "water_heater", "sensor", "binary_sensor", "switch"]: opp.async_create_task(async_load_platform(opp, platform, DOMAIN, {}, config)) setup_service_functions(opp, broker) return True
async def async_setup(opp, config): """Set up the Kaiterra integration.""" conf = config[DOMAIN] scan_interval = conf[CONF_SCAN_INTERVAL] devices = conf[CONF_DEVICES] session = async_get_clientsession(opp) api = opp.data[DOMAIN] = KaiterraApiData(opp, conf, session) await api.async_update() async def _update(now=None): """Periodic update.""" await api.async_update() async_track_time_interval(opp, _update, scan_interval) # Load platforms for each device for device in devices: device_name, device_id = ( device.get(CONF_NAME) or device[CONF_TYPE], device[CONF_DEVICE_ID], ) for platform in PLATFORMS: opp.async_create_task( async_load_platform( opp, platform, DOMAIN, {CONF_NAME: device_name, CONF_DEVICE_ID: device_id}, config, ) ) return True
async def async_setup(opp: OpenPeerPower, config: ConfigType): """Set up the mobile app component.""" store = opp.helpers.storage.Store(STORAGE_VERSION, STORAGE_KEY) app_config = await store.async_load() if app_config is None: app_config = { DATA_CONFIG_ENTRIES: {}, DATA_DELETED_IDS: [], } opp.data[DOMAIN] = { DATA_CONFIG_ENTRIES: {}, DATA_DELETED_IDS: app_config.get(DATA_DELETED_IDS, []), DATA_DEVICES: {}, DATA_PUSH_CHANNEL: {}, DATA_STORE: store, } opp.http.register_view(RegistrationsView()) for deleted_id in opp.data[DOMAIN][DATA_DELETED_IDS]: with suppress(ValueError): webhook_register(opp, DOMAIN, "Deleted Webhook", deleted_id, handle_webhook) opp.async_create_task( discovery.async_load_platform(opp, "notify", DOMAIN, {}, config)) websocket_api.async_register_command(opp, handle_push_notification_channel) return True
async def async_setup(opp, config): """Set up the iperf3 component.""" opp.data[DOMAIN] = {} conf = config[DOMAIN] for host in conf[CONF_HOSTS]: data = opp.data[DOMAIN][host[CONF_HOST]] = Iperf3Data(opp, host) if not conf[CONF_MANUAL]: async_track_time_interval(opp, data.update, conf[CONF_SCAN_INTERVAL]) def update(call): """Service call to manually update the data.""" called_host = call.data[ATTR_HOST] if called_host in opp.data[DOMAIN]: opp.data[DOMAIN][called_host].update() else: for iperf3_host in opp.data[DOMAIN].values(): iperf3_host.update() opp.services.async_register(DOMAIN, "speedtest", update, schema=SERVICE_SCHEMA) opp.async_create_task( async_load_platform(opp, SENSOR_DOMAIN, DOMAIN, conf[CONF_MONITORED_CONDITIONS], config)) return True
async def async_setup(opp, config): """Set up the Unify Circuit component.""" webhooks = config[DOMAIN][CONF_WEBHOOK] for webhook_conf in webhooks: opp.async_create_task( discovery.async_load_platform(opp, "notify", DOMAIN, webhook_conf, config) ) return True
async def async_setup(opp, config): """Set up the Melissa Climate component.""" conf = config[DOMAIN] username = conf.get(CONF_USERNAME) password = conf.get(CONF_PASSWORD) api = melissa.AsyncMelissa(username=username, password=password) await api.async_connect() opp.data[DATA_MELISSA] = api opp.async_create_task(async_load_platform(opp, "climate", DOMAIN, {}, config)) return True
async def async_setup(opp, config): """Set up the SPC component.""" async def async_upate_callback(spc_object): if isinstance(spc_object, Area): async_dispatcher_send(opp, SIGNAL_UPDATE_ALARM.format(spc_object.id)) elif isinstance(spc_object, Zone): async_dispatcher_send(opp, SIGNAL_UPDATE_SENSOR.format(spc_object.id)) session = aiohttp_client.async_get_clientsession(opp) spc = SpcWebGateway( loop=opp.loop, session=session, api_url=config[DOMAIN].get(CONF_API_URL), ws_url=config[DOMAIN].get(CONF_WS_URL), async_callback=async_upate_callback, ) opp.data[DATA_API] = spc if not await spc.async_load_parameters(): _LOGGER.error("Failed to load area/zone information from SPC") return False # add sensor devices for each zone (typically motion/fire/door sensors) opp.async_create_task( discovery.async_load_platform(opp, "binary_sensor", DOMAIN, {}, config)) # create a separate alarm panel for each area opp.async_create_task( discovery.async_load_platform(opp, "alarm_control_panel", DOMAIN, {}, config)) # start listening for incoming events over websocket spc.start() return True
async def async_setup_entry(opp: OpenPeerPower, entry: ConfigEntry): """Set up BMW Connected Drive from a config entry.""" opp.data.setdefault(DOMAIN, {}) opp.data[DOMAIN].setdefault(DATA_ENTRIES, {}) _async_migrate_options_from_data_if_missing(opp, entry) try: account = await opp.async_add_executor_job(setup_account, entry, opp, entry.data[CONF_USERNAME]) except OSError as ex: raise ConfigEntryNotReady from ex async def _async_update_all(service_call=None): """Update all BMW accounts.""" await opp.async_add_executor_job(_update_all) def _update_all() -> None: """Update all BMW accounts.""" for entry in opp.data[DOMAIN][DATA_ENTRIES].copy().values(): entry[CONF_ACCOUNT].update() # Add update listener for config entry changes (options) undo_listener = entry.add_update_listener(update_listener) opp.data[DOMAIN][DATA_ENTRIES][entry.entry_id] = { CONF_ACCOUNT: account, UNDO_UPDATE_LISTENER: undo_listener, } # Service to manually trigger updates for all accounts. opp.services.async_register(DOMAIN, SERVICE_UPDATE_STATE, _async_update_all) await _async_update_all() opp.config_entries.async_setup_platforms( entry, [platform for platform in PLATFORMS if platform != NOTIFY_DOMAIN]) # set up notify platform, no entry support for notify platform yet, # have to use discovery to load platform. opp.async_create_task( discovery.async_load_platform( opp, NOTIFY_DOMAIN, DOMAIN, {CONF_NAME: DOMAIN}, opp.data[DOMAIN][DATA_OPP_CONFIG], )) return True
async def async_setup(opp, config): """Set up the Compensation sensor.""" opp.data[DATA_COMPENSATION] = {} for compensation, conf in config.get(DOMAIN).items(): _LOGGER.debug("Setup %s.%s", DOMAIN, compensation) degree = conf[CONF_DEGREE] # get x values and y values from the x,y point pairs x_values, y_values = zip(*conf[CONF_DATAPOINTS]) # try to get valid coefficients for a polynomial coefficients = None with np.errstate(all="raise"): with warnings.catch_warnings(record=True) as all_warnings: warnings.simplefilter("always") try: coefficients = np.polyfit(x_values, y_values, degree) except FloatingPointError as error: _LOGGER.error( "Setup of %s encountered an error, %s", compensation, error, ) for warning in all_warnings: _LOGGER.warning( "Setup of %s encountered a warning, %s", compensation, str(warning.message).lower(), ) if coefficients is not None: data = { k: v for k, v in conf.items() if k not in [CONF_DEGREE, CONF_DATAPOINTS] } data[CONF_POLYNOMIAL] = np.poly1d(coefficients) opp.data[DATA_COMPENSATION][compensation] = data opp.async_create_task( async_load_platform( opp, SENSOR_DOMAIN, DOMAIN, {CONF_COMPENSATION: compensation}, config, ) ) return True
def discover_mysensors_platform(opp, opp_config, platform, new_devices): """Discover a MySensors platform.""" task = opp.async_create_task( discovery.async_load_platform( opp, platform, DOMAIN, { ATTR_DEVICES: new_devices, CONF_NAME: DOMAIN }, opp_config, )) return task
async def async_setup_entry(opp, entry): """Load a config entry. Validate and save sessions per aws credential. """ config = opp.data.get(DATA_OPP_CONFIG) conf = opp.data.get(DATA_CONFIG) if entry.source == config_entries.SOURCE_IMPORT: if conf is None: # user removed config from configuration.yaml, abort setup opp.async_create_task( opp.config_entries.async_remove(entry.entry_id)) return False if conf != entry.data: # user changed config from configuration.yaml, use conf to setup opp.config_entries.async_update_entry(entry, data=conf) if conf is None: conf = CONFIG_SCHEMA({DOMAIN: entry.data})[DOMAIN] # validate credentials and create sessions validation = True tasks = [] for cred in conf[ATTR_CREDENTIALS]: tasks.append(_validate_aws_credentials(opp, cred)) if tasks: results = await asyncio.gather(*tasks, return_exceptions=True) for index, result in enumerate(results): name = conf[ATTR_CREDENTIALS][index][CONF_NAME] if isinstance(result, Exception): _LOGGER.error( "Validating credential [%s] failed: %s", name, result, exc_info=result, ) validation = False else: opp.data[DATA_SESSIONS][name] = result # set up notify platform, no entry support for notify component yet, # have to use discovery to load platform. for notify_config in conf[CONF_NOTIFY]: opp.async_create_task( discovery.async_load_platform(opp, "notify", DOMAIN, notify_config, config)) return validation
async def async_setup(opp, config): """Set up the client and boot the platforms.""" conf = config[DOMAIN] host = conf.get(CONF_HOST) name = conf.get(CONF_NAME) client = Vallox(host) state_proxy = ValloxStateProxy(opp, client) service_handler = ValloxServiceHandler(client, state_proxy) opp.data[DOMAIN] = { "client": client, "state_proxy": state_proxy, "name": name } for vallox_service in SERVICE_TO_METHOD: schema = SERVICE_TO_METHOD[vallox_service]["schema"] opp.services.async_register(DOMAIN, vallox_service, service_handler.async_handle, schema=schema) # The vallox hardware expects quite strict timings for websocket # requests. Timings that machines with less processing power, like # Raspberries, cannot live up to during the busy start phase of Home # Asssistant. Hence, async_add_entities() for fan and sensor in respective # code will be called with update_before_add=False to intentionally delay # the first request, increasing chance that it is issued only when the # machine is less busy again. opp.async_create_task( async_load_platform(opp, "sensor", DOMAIN, {}, config)) opp.async_create_task(async_load_platform(opp, "fan", DOMAIN, {}, config)) async_track_time_interval(opp, state_proxy.async_update, SCAN_INTERVAL) return True
async def async_setup(opp, config): """Set up the velux component.""" try: opp.data[DATA_VELUX] = VeluxModule(opp, config[DOMAIN]) opp.data[DATA_VELUX].setup() await opp.data[DATA_VELUX].async_start() except PyVLXException as ex: _LOGGER.exception("Can't connect to velux interface: %s", ex) return False for platform in PLATFORMS: opp.async_create_task( discovery.async_load_platform(opp, platform, DOMAIN, {}, config) ) return True
async def async_setup(opp, config): """Check connectivity and version of KEBA charging station.""" host = config[DOMAIN][CONF_HOST] rfid = config[DOMAIN][CONF_RFID] refresh_interval = config[DOMAIN][CONF_FS_INTERVAL] keba = KebaHandler(opp, host, rfid, refresh_interval) opp.data[DOMAIN] = keba # Wait for KebaHandler setup complete (initial values loaded) if not await keba.setup(): _LOGGER.error("Could not find a charging station at %s", host) return False # Set failsafe mode at start up of Open Peer Power failsafe = config[DOMAIN][CONF_FS] timeout = config[DOMAIN][CONF_FS_TIMEOUT] if failsafe else 0 fallback = config[DOMAIN][CONF_FS_FALLBACK] if failsafe else 0 persist = config[DOMAIN][CONF_FS_PERSIST] if failsafe else 0 try: opp.loop.create_task(keba.set_failsafe(timeout, fallback, persist)) except ValueError as ex: _LOGGER.warning("Could not set failsafe mode %s", ex) # Register services to opp async def execute_service(call): """Execute a service to KEBA charging station. This must be a member function as we need access to the keba object here. """ function_name = _SERVICE_MAP[call.service] function_call = getattr(keba, function_name) await function_call(call.data) for service in _SERVICE_MAP: opp.services.async_register(DOMAIN, service, execute_service) # Load components for domain in SUPPORTED_COMPONENTS: opp.async_create_task( discovery.async_load_platform(opp, domain, DOMAIN, {}, config)) # Start periodic polling of charging station data keba.start_periodic_request() return True
def setup(opp, config): """Set up the ZoneMinder component.""" opp.data[DOMAIN] = {} success = True for conf in config[DOMAIN]: protocol = "https" if conf[CONF_SSL] else "http" host_name = conf[CONF_HOST] server_origin = f"{protocol}://{host_name}" zm_client = ZoneMinder( server_origin, conf.get(CONF_USERNAME), conf.get(CONF_PASSWORD), conf.get(CONF_PATH), conf.get(CONF_PATH_ZMS), conf.get(CONF_VERIFY_SSL), ) opp.data[DOMAIN][host_name] = zm_client success = zm_client.login() and success def set_active_state(call): """Set the ZoneMinder run state to the given state name.""" zm_id = call.data[ATTR_ID] state_name = call.data[ATTR_NAME] if zm_id not in opp.data[DOMAIN]: _LOGGER.error("Invalid ZoneMinder host provided: %s", zm_id) if not opp.data[DOMAIN][zm_id].set_active_state(state_name): _LOGGER.error( "Unable to change ZoneMinder state. Host: %s, state: %s", zm_id, state_name, ) opp.services.register(DOMAIN, SERVICE_SET_RUN_STATE, set_active_state, schema=SET_RUN_STATE_SCHEMA) opp.async_create_task( async_load_platform(opp, "binary_sensor", DOMAIN, {}, config)) return success
async def _async_process_config(opp, config) -> bool: """Process rest configuration.""" if DOMAIN not in config: return True refresh_tasks = [] load_tasks = [] for rest_idx, conf in enumerate(config[DOMAIN]): scan_interval = conf.get(CONF_SCAN_INTERVAL, DEFAULT_SCAN_INTERVAL) resource_template = conf.get(CONF_RESOURCE_TEMPLATE) rest = create_rest_data_from_config(opp, conf) coordinator = _rest_coordinator(opp, rest, resource_template, scan_interval) refresh_tasks.append(coordinator.async_refresh()) opp.data[DOMAIN][REST_DATA].append({ REST: rest, COORDINATOR: coordinator }) for platform_domain in COORDINATOR_AWARE_PLATFORMS: if platform_domain not in conf: continue for platform_conf in conf[platform_domain]: opp.data[DOMAIN][platform_domain].append(platform_conf) platform_idx = len(opp.data[DOMAIN][platform_domain]) - 1 load = discovery.async_load_platform( opp, platform_domain, DOMAIN, { REST_IDX: rest_idx, PLATFORM_IDX: platform_idx }, config, ) load_tasks.append(load) if refresh_tasks: await asyncio.gather(*refresh_tasks) if load_tasks: await asyncio.gather(*load_tasks) return True
async def async_setup(opp, config): """Set up the Fast.com component.""" conf = config[DOMAIN] data = opp.data[DOMAIN] = SpeedtestData(opp) if not conf[CONF_MANUAL]: async_track_time_interval(opp, data.update, conf[CONF_SCAN_INTERVAL]) def update(call=None): """Service call to manually update the data.""" data.update() opp.services.async_register(DOMAIN, "speedtest", update) opp.async_create_task( async_load_platform(opp, "sensor", DOMAIN, {}, config)) return True
def async_setup_sabnzbd(opp, sab_api, config, name): """Set up SABnzbd sensors and services.""" sab_api_data = SabnzbdApiData(sab_api, name, config.get(CONF_SENSORS, {})) if config.get(CONF_SENSORS): opp.data[DATA_SABNZBD] = sab_api_data opp.async_create_task( discovery.async_load_platform(opp, "sensor", DOMAIN, {}, config)) async def async_service_handler(service): """Handle service calls.""" if service.service == SERVICE_PAUSE: await sab_api_data.async_pause_queue() elif service.service == SERVICE_RESUME: await sab_api_data.async_resume_queue() elif service.service == SERVICE_SET_SPEED: speed = service.data.get(ATTR_SPEED) await sab_api_data.async_set_queue_speed(speed) opp.services.async_register(DOMAIN, SERVICE_PAUSE, async_service_handler, schema=vol.Schema({})) opp.services.async_register(DOMAIN, SERVICE_RESUME, async_service_handler, schema=vol.Schema({})) opp.services.async_register(DOMAIN, SERVICE_SET_SPEED, async_service_handler, schema=SPEED_LIMIT_SCHEMA) async def async_update_sabnzbd(now): """Refresh SABnzbd queue data.""" try: await sab_api.refresh_data() async_dispatcher_send(opp, SIGNAL_SABNZBD_UPDATED, None) except SabnzbdApiException as err: _LOGGER.error(err) async_track_time_interval(opp, async_update_sabnzbd, UPDATE_INTERVAL)
async def async_setup(opp, config): """Set up TP-Link LTE component.""" if DATA_KEY not in opp.data: websession = async_create_clientsession( opp, cookie_jar=aiohttp.CookieJar(unsafe=True)) opp.data[DATA_KEY] = LTEData(websession) domain_config = config.get(DOMAIN, []) tasks = [_setup_lte(opp, conf) for conf in domain_config] if tasks: await asyncio.wait(tasks) for conf in domain_config: for notify_conf in conf.get(CONF_NOTIFY, []): opp.async_create_task( discovery.async_load_platform(opp, "notify", DOMAIN, notify_conf, config)) return True
async def async_setup(self, opp_config): """Set up the trigger and create entities.""" if self.opp.state == CoreState.running: await self._attach_triggers() else: self._unsub_start = self.opp.bus.async_listen_once( EVENT_OPENPEERPOWER_START, self._attach_triggers) for platform_domain in PLATFORMS: if platform_domain in self.config: self.opp.async_create_task( discovery.async_load_platform( self.opp, platform_domain, DOMAIN, { "coordinator": self, "entities": self.config[platform_domain] }, opp_config, ))
async def _process_config(opp, opp_config): """Process config.""" coordinators: list[TriggerUpdateCoordinator] | None = opp.data.pop( DOMAIN, None) # Remove old ones if coordinators: for coordinator in coordinators: coordinator.async_remove() async def init_coordinator(opp, conf_section): coordinator = TriggerUpdateCoordinator(opp, conf_section) await coordinator.async_setup(opp_config) return coordinator coordinator_tasks = [] for conf_section in opp_config[DOMAIN]: if CONF_TRIGGER in conf_section: coordinator_tasks.append(init_coordinator(opp, conf_section)) continue for platform_domain in PLATFORMS: if platform_domain in conf_section: opp.async_create_task( discovery.async_load_platform( opp, platform_domain, DOMAIN, { "unique_id": conf_section.get(CONF_UNIQUE_ID), "entities": conf_section[platform_domain], }, opp_config, )) if coordinator_tasks: opp.data[DOMAIN] = await asyncio.gather(*coordinator_tasks)
def discover_vehicle(vehicle): """Load relevant platforms.""" data.vehicles.add(vehicle.vin) dashboard = vehicle.dashboard( mutable=config[DOMAIN][CONF_MUTABLE], scandinavian_miles=config[DOMAIN][CONF_SCANDINAVIAN_MILES], ) for instrument in (instrument for instrument in dashboard.instruments if instrument.component in PLATFORMS and is_enabled(instrument.slug_attr)): data.instruments.add(instrument) opp.async_create_task( discovery.async_load_platform( opp, PLATFORMS[instrument.component], DOMAIN, (vehicle.vin, instrument.component, instrument.attr), config, ))
async def async_setup_entry(opp, entry): """Set up a config entry.""" tibber_connection = tibber.Tibber( access_token=entry.data[CONF_ACCESS_TOKEN], websession=async_get_clientsession(opp), time_zone=dt_util.DEFAULT_TIME_ZONE, ) opp.data[DOMAIN] = tibber_connection async def _close(event): await tibber_connection.rt_disconnect() entry.async_on_unload( opp.bus.async_listen_once(EVENT_OPENPEERPOWER_STOP, _close)) try: await tibber_connection.update_info() except asyncio.TimeoutError as err: raise ConfigEntryNotReady from err except aiohttp.ClientError as err: _LOGGER.error("Error connecting to Tibber: %s ", err) return False except tibber.InvalidLogin as exp: _LOGGER.error("Failed to login. %s", exp) return False opp.config_entries.async_setup_platforms(entry, PLATFORMS) # set up notify platform, no entry support for notify component yet, # have to use discovery to load platform. opp.async_create_task( discovery.async_load_platform(opp, "notify", DOMAIN, {CONF_NAME: DOMAIN}, opp.data[DATA_OPP_CONFIG])) return True
def _load_platform(opp, config, entity_type, entity_info_list): """Load platform with list of entity info.""" opp.async_create_task( async_load_platform(opp, entity_type, DOMAIN, entity_info_list, config))