async def async_validate_input(self, user_input: dict[str, Any]) -> FlowResult: """Validate user credentials.""" username = user_input.get(CONF_USERNAME) password = user_input.get(CONF_PASSWORD) server = SUPPORTED_SERVERS[user_input.get(CONF_HUB, DEFAULT_HUB)] async with TahomaClient(username, password, api_url=server.endpoint) as client: await client.login() # Set first gateway as unique id gateways = await client.get_gateways() if gateways: gateway_id = gateways[0].id await self.async_set_unique_id(gateway_id) # Create new config entry if (self._reauth_entry is None or self._reauth_entry.unique_id != self.unique_id): self._abort_if_unique_id_configured() return self.async_create_entry(title=username, data=user_input) # Modify existing entry in reauth scenario self.hass.config_entries.async_update_entry(self._reauth_entry, data=user_input) await self.hass.config_entries.async_reload( self._reauth_entry.entry_id) return self.async_abort(reason="reauth_successful")
async def async_validate_input(self, user_input): """Validate user credentials.""" username = user_input.get(CONF_USERNAME) password = user_input.get(CONF_PASSWORD) async with TahomaClient(username, password) as client: await client.login() return self.async_create_entry(title=username, data=user_input)
async def async_validate_input(self, user_input): """Validate user credentials.""" username = user_input.get(CONF_USERNAME) password = user_input.get(CONF_PASSWORD) hub = user_input.get(CONF_HUB, DEFAULT_HUB) endpoint = SUPPORTED_ENDPOINTS[hub] async with TahomaClient(username, password, api_url=endpoint) as client: await client.login() return self.async_create_entry( title=username, data=user_input, )
async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry): """Set up TaHoma from a config entry.""" hass.data.setdefault(DOMAIN, {}) username = entry.data.get(CONF_USERNAME) password = entry.data.get(CONF_PASSWORD) session = aiohttp_client.async_create_clientsession( hass, cookie_jar=CookieJar(unsafe=True)) client = TahomaClient(username, password, session=session) try: await client.login() except TooManyRequestsException: _LOGGER.error("too_many_requests") return False except BadCredentialsException: _LOGGER.error("invalid_auth") return False except Exception as exception: # pylint: disable=broad-except _LOGGER.exception(exception) return False update_interval = entry.options.get(CONF_UPDATE_INTERVAL, DEFAULT_UPDATE_INTERVAL) tahoma_coordinator = TahomaDataUpdateCoordinator( hass, _LOGGER, name="TaHoma Event Fetcher", client=client, devices=await client.get_devices(), update_interval=timedelta(seconds=update_interval), ) await tahoma_coordinator.async_refresh() entities = defaultdict(list) entities[SCENE] = await client.get_scenarios() hass.data[DOMAIN][entry.entry_id] = { "entities": entities, "coordinator": tahoma_coordinator, "update_listener": entry.add_update_listener(update_listener), } for device in tahoma_coordinator.data.values(): platform = TAHOMA_TYPES.get(device.widget) or TAHOMA_TYPES.get( device.ui_class) if platform: entities[platform].append(device) elif (device.widget not in IGNORED_TAHOMA_TYPES and device.ui_class not in IGNORED_TAHOMA_TYPES): _LOGGER.debug( "Unsupported TaHoma device detected (%s - %s - %s)", device.controllable_name, device.ui_class, device.widget, ) for platform in entities: hass.async_create_task( hass.config_entries.async_forward_entry_setup(entry, platform)) return True
def api(self): return TahomaClient("username", "password")
async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry): """Set up TaHoma from a config entry.""" hass.data.setdefault(DOMAIN, {}) username = entry.data.get(CONF_USERNAME) password = entry.data.get(CONF_PASSWORD) session = aiohttp_client.async_create_clientsession(hass) client = TahomaClient(username, password, session=session) try: await client.login() devices = await client.get_devices() scenarios = await client.get_scenarios() except BadCredentialsException: _LOGGER.error("invalid_auth") return False except TooManyRequestsException as exception: _LOGGER.error("too_many_requests") raise ConfigEntryNotReady from exception except (TimeoutError, ClientError, ServerDisconnectedError) as exception: _LOGGER.error("cannot_connect") raise ConfigEntryNotReady from exception except MaintenanceException as exception: _LOGGER.error("server_in_maintenance") raise ConfigEntryNotReady from exception except Exception as exception: # pylint: disable=broad-except _LOGGER.exception(exception) return False update_interval = entry.options.get(CONF_UPDATE_INTERVAL, DEFAULT_UPDATE_INTERVAL) tahoma_coordinator = TahomaDataUpdateCoordinator( hass, _LOGGER, name="TaHoma Event Fetcher", client=client, devices=devices, update_interval=timedelta(seconds=update_interval), ) await tahoma_coordinator.async_refresh() entities = defaultdict(list) entities[SCENE] = scenarios hass.data[DOMAIN][entry.entry_id] = { "entities": entities, "coordinator": tahoma_coordinator, "update_listener": entry.add_update_listener(update_listener), } for device in tahoma_coordinator.data.values(): platform = TAHOMA_TYPES.get(device.widget) or TAHOMA_TYPES.get( device.ui_class) if platform: entities[platform].append(device) elif (device.widget not in IGNORED_TAHOMA_TYPES and device.ui_class not in IGNORED_TAHOMA_TYPES): _LOGGER.debug( "Unsupported TaHoma device detected (%s - %s - %s)", device.controllable_name, device.ui_class, device.widget, ) for platform in entities: hass.async_create_task( hass.config_entries.async_forward_entry_setup(entry, platform)) async def handle_execute_command(call): """Handle execute command service.""" entity_registry = await hass.helpers.entity_registry.async_get_registry( ) entity = entity_registry.entities.get(call.data.get("entity_id")) await tahoma_coordinator.client.execute_command( entity.unique_id, Command(call.data.get("command"), call.data.get("args")), "Home Assistant Service", ) hass.services.async_register( DOMAIN, SERVICE_EXECUTE_COMMAND, handle_execute_command, vol.Schema({ vol.Required("entity_id"): cv.string, vol.Required("command"): cv.string, vol.Optional("args", default=[]): vol.All(cv.ensure_list, [vol.Any(str, int)]), }), ) return True
async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool: """Set up TaHoma from a config entry.""" hass.data.setdefault(DOMAIN, {}) username = entry.data.get(CONF_USERNAME) password = entry.data.get(CONF_PASSWORD) server = SUPPORTED_SERVERS[entry.data.get(CONF_HUB, DEFAULT_HUB)] session = async_get_clientsession(hass) client = TahomaClient( username, password, session=session, api_url=server.endpoint, ) try: await client.login() tasks = [ client.get_devices(), client.get_scenarios(), client.get_gateways(), client.get_places(), ] devices, scenarios, gateways, places = await asyncio.gather(*tasks) except BadCredentialsException as exception: raise ConfigEntryAuthFailed from exception except TooManyRequestsException as exception: raise ConfigEntryNotReady( "Too many requests, try again later") from exception except (TimeoutError, ClientError, ServerDisconnectedError) as exception: raise ConfigEntryNotReady("Failed to connect") from exception except MaintenanceException as exception: raise ConfigEntryNotReady( "Server is down for maintenance") from exception except Exception as exception: # pylint: disable=broad-except _LOGGER.exception(exception) return False update_interval = timedelta(seconds=entry.options.get( CONF_UPDATE_INTERVAL, DEFAULT_UPDATE_INTERVAL)) coordinator = OverkizDataUpdateCoordinator( hass, _LOGGER, name="device events", client=client, devices=devices, places=places, update_interval=update_interval, config_entry_id=entry.entry_id, ) _LOGGER.debug("Initialized DataUpdateCoordinator with %s interval.", str(update_interval)) await coordinator.async_refresh() platforms = defaultdict(list) platforms[SCENE] = scenarios hass.data[DOMAIN][entry.entry_id] = { "platforms": platforms, "coordinator": coordinator, "update_listener": entry.add_update_listener(update_listener), } # Map Overkiz device to Home Assistant platform for device in coordinator.data.values(): platform = OVERKIZ_DEVICE_TO_PLATFORM.get( device.widget) or OVERKIZ_DEVICE_TO_PLATFORM.get(device.ui_class) if platform: platforms[platform].append(device) log_device("Added device", device) elif (device.widget not in IGNORED_OVERKIZ_DEVICES and device.ui_class not in IGNORED_OVERKIZ_DEVICES): log_device("Unsupported device detected", device) if device.widget == HOMEKIT_STACK: print_homekit_setup_code(device) supported_platforms = set(platforms.keys()) # Sensor and Binary Sensor will be added dynamically, based on the device states # Switch will be added dynamically, based on device features (e.g. low speed cover switch) supported_platforms.update((BINARY_SENSOR, SENSOR, SWITCH)) for platform in supported_platforms: hass.async_create_task( hass.config_entries.async_forward_entry_setup(entry, platform)) device_registry = await dr.async_get_registry(hass) for gateway in gateways: _LOGGER.debug( "Added gateway (%s - %s - %s)", gateway.id, gateway.type, gateway.sub_type, ) gateway_model = (beautify_name(gateway.sub_type.name) if isinstance( gateway.sub_type, Enum) else None) gateway_name = (f"{beautify_name(gateway.type.name)} hub" if isinstance(gateway.type, Enum) else gateway.type) device_registry.async_get_or_create( config_entry_id=entry.entry_id, identifiers={(DOMAIN, gateway.id)}, model=gateway_model, manufacturer=server.manufacturer, name=gateway_name, sw_version=gateway.connectivity.protocol_version, ) async def handle_execute_command(call: ServiceCall): """Handle execute command service.""" entity_registry = await hass.helpers.entity_registry.async_get_registry( ) for entity_id in call.data.get("entity_id"): entity = entity_registry.entities.get(entity_id) try: await coordinator.client.execute_command( entity.unique_id, Command(call.data.get("command"), call.data.get("args")), "Home Assistant Service", ) except InvalidCommandException as exception: _LOGGER.error(exception) service.async_register_admin_service( hass, DOMAIN, SERVICE_EXECUTE_COMMAND, handle_execute_command, vol.Schema( { vol.Required("entity_id"): [cv.entity_id], vol.Required("command"): cv.string, vol.Optional("args", default=[]): vol.All(cv.ensure_list, [vol.Any(str, int)]), }, ), ) async def handle_get_execution_history(call): """Handle get execution history service.""" await write_execution_history_to_log(coordinator.client) service.async_register_admin_service( hass, DOMAIN, "get_execution_history", handle_get_execution_history, ) return True