async def async_step_init(self, user_input: Dict[str, str] = None) -> Dict[str, str]: """Manage the options for the custom component.""" errors: Dict[str, str] = {} # Grab all devices from the entity registry so we can populate the # dropdown list that will allow a user to configure a device. entity_registry = await async_get_registry(self.hass) devices = async_entries_for_config_entry(entity_registry, self.config_entry.entry_id) stats = { e.unique_id: e.capabilities for e in devices if e.entity_id.startswith('climate.') } if user_input is not None: _LOGGER.debug(f"user_input: {user_input}") _LOGGER.debug(f"original config: {self.config}") # Remove any devices where hvac_modes have been unset. remove_devices = [ unique_id for unique_id in stats.keys() if unique_id == user_input["device"] if len(user_input["hvac_modes"]) == 0 ] for unique_id in remove_devices: if unique_id in self.config: self.config.pop(unique_id) if len(user_input["hvac_modes"]) != 0: if not errors: # Add the new device config. self.config[ user_input["device"]] = user_input["hvac_modes"] _LOGGER.debug(f"updated config: {self.config}") if not errors: # If user selected the 'more' tickbox, show this form again # so they can configure additional devices. if user_input.get('more', False): return await self.async_step_init() # Value of data will be set on the options property of the config_entry instance. return self.async_create_entry( title="", data={CONF_HVAC_MODES: self.config}) options_schema = vol.Schema({ vol.Optional("device", default=list(stats.keys())): vol.In(stats.keys()), vol.Optional("hvac_modes", default=list(default_modes)): cv.multi_select(modes), vol.Optional("more"): cv.boolean }) return self.async_show_form(step_id="init", data_schema=options_schema, errors=errors)
async def async_step_advanced(self, user_input: dict[str, Any] | None = None ) -> FlowResult: """Choose advanced options.""" if (not self.show_advanced_options or user_input is not None or self.hk_options[CONF_HOMEKIT_MODE] != HOMEKIT_MODE_BRIDGE): if user_input: self.hk_options.update(user_input) if (self.show_advanced_options and self.hk_options[CONF_HOMEKIT_MODE] == HOMEKIT_MODE_BRIDGE): self.hk_options[CONF_DEVICES] = user_input[CONF_DEVICES] for key in (CONF_DOMAINS, CONF_ENTITIES): if key in self.hk_options: del self.hk_options[key] if CONF_INCLUDE_EXCLUDE_MODE in self.hk_options: del self.hk_options[CONF_INCLUDE_EXCLUDE_MODE] return self.async_create_entry(title="", data=self.hk_options) all_supported_devices = await _async_get_supported_devices(self.hass) # Strip out devices that no longer exist to prevent error in the UI devices = [ device_id for device_id in self.hk_options.get(CONF_DEVICES, []) if device_id in all_supported_devices ] return self.async_show_form( step_id="advanced", data_schema=vol.Schema({ vol.Optional(CONF_DEVICES, default=devices): cv.multi_select(all_supported_devices) }), )
async def async_step_events(self, user_input=None): """Manage event options.""" if user_input is not None: if ADD_NEW_EVENT not in user_input: self.options[CONF_SUBSCRIBE_EVENTS] = user_input.get( CONF_SUBSCRIBE_EVENTS, []) return self.async_create_entry(title="", data=self.options) selected = user_input.get(CONF_SUBSCRIBE_EVENTS, []) self.events.add(user_input[ADD_NEW_EVENT]) selected.append(user_input[ADD_NEW_EVENT]) else: self.events = set( self.config_entry.options.get(CONF_SUBSCRIBE_EVENTS) or []) selected = self._default(CONF_SUBSCRIBE_EVENTS) return self.async_show_form( step_id="events", data_schema=vol.Schema({ vol.Optional(CONF_SUBSCRIBE_EVENTS, default=selected): cv.multi_select(self.events), vol.Optional(ADD_NEW_EVENT): str, }), )
async def async_step_init(self, user_input: dict[str, Any] | None = None ) -> FlowResult: """Manage the Kraken options.""" if user_input is not None: return self.async_create_entry(title="", data=user_input) api = KrakenAPI(krakenex.API(), retry=0, crl_sleep=0) tradable_asset_pairs = await self.hass.async_add_executor_job( get_tradable_asset_pairs, api) tradable_asset_pairs_for_multi_select = { v: v for v in tradable_asset_pairs.keys() } options = { vol.Optional( CONF_SCAN_INTERVAL, default=self.config_entry.options.get( CONF_SCAN_INTERVAL, DEFAULT_SCAN_INTERVAL ), ): int, vol.Optional( CONF_TRACKED_ASSET_PAIRS, default=self.config_entry.options.get(CONF_TRACKED_ASSET_PAIRS, []), ): cv.multi_select(tradable_asset_pairs_for_multi_select), } return self.async_show_form(step_id="init", data_schema=vol.Schema(options))
async def async_step_repositories( self, user_input: dict[str, Any] | None = None, ) -> FlowResult: """Handle repositories step.""" # mypy is not aware that we can't get here without having this set already assert self._login is not None if not user_input: repositories = await get_repositories(self.hass, self._login.access_token) return self.async_show_form( step_id="repositories", data_schema=vol.Schema( { vol.Required(CONF_REPOSITORIES): cv.multi_select( {k: k for k in repositories} ), } ), ) return self.async_create_entry( title="", data={CONF_ACCESS_TOKEN: self._login.access_token}, options={CONF_REPOSITORIES: user_input[CONF_REPOSITORIES]}, )
async def async_step_forecasts_monitored(self, user_input=None): """Handle the forecasts monitored step.""" monitored = { "temp_max": "Max. Temperature", "temp_min": "Min. Temperature", "extended_text": "Extended Text", "icon_descriptor": "Icon Descriptor", "mdi_icon": "MDI Icon", "short_text": "Short Text", "uv_category": "UV Category", "uv_max_index": "UV Max Index", "uv_start_time": "UV Protection Start Time", "uv_end_time": "UV Protection End Time", "uv_forecast": "UV Forecast Summary", "rain_amount_min": "Rain Amount Min.", "rain_amount_max": "Rain Amount Max.", "rain_amount_range": "Rain Amount Range", "rain_chance": "Rain Chance", "fire_danger": "Fire Danger", "now_now_label": "Now Now Label", "now_temp_now": "Now Temp Now", "now_later_label": "Now Later Label", "now_temp_later": "Now Temp Later", "astronomical_sunrise_time": "Sunrise Time", "astronomical_sunset_time": "Sunset Time", } data_schema = vol.Schema({ vol.Required( CONF_FORECASTS_BASENAME, default=self.collector.locations_data["data"]["name"], ): str, vol.Required(CONF_FORECASTS_MONITORED): cv.multi_select(monitored), vol.Required(CONF_FORECASTS_DAYS): vol.All(vol.Coerce(int), vol.Range(0, 7)), }) errors = {} if user_input is not None: try: self.data.update(user_input) if self.data[CONF_WARNINGS_CREATE]: return await self.async_step_warnings_basename() return self.async_create_entry( title=self.collector.locations_data["data"]["name"], data=self.data) except CannotConnect: errors["base"] = "cannot_connect" except Exception: _LOGGER.exception("Unexpected exception") errors["base"] = "unknown" # If there is no user input or there were errors, show the form again, including any errors that were found with the input. return self.async_show_form(step_id="forecasts_monitored", data_schema=data_schema, errors=errors)
async def async_step_options_2(self, user_input=None): """Manage the options 2.""" if user_input is not None: self.options.update(user_input) return await self._update_options() return self.async_show_form( step_id="options_2", data_schema=vol.Schema({ vol.Optional( CONF_STRING, default=self.config_entry.options.get( CONF_STRING, "Default", ), ): str, vol.Optional( CONF_SELECT, default=self.config_entry.options.get( CONF_SELECT, "default"), ): vol.In(["default", "other"]), vol.Optional( CONF_MULTISELECT, default=self.config_entry.options.get( CONF_MULTISELECT, ["default"]), ): cv.multi_select({ "default": "Default", "other": "Other" }), }), )
async def async_step_select_instruments(self, user_input=None): if user_input is not None: self._init_info[CONF_RESOURCES] = user_input[CONF_RESOURCES] del self._init_info["CONF_VEHICLES"] if self._init_info[CONF_NAME] is None: self._init_info[CONF_NAME] = self._init_info[CONF_VEHICLE] await self.async_set_unique_id(self._init_info[CONF_VEHICLE]) self._abort_if_unique_id_configured() return self.async_create_entry(title=self._init_info[CONF_NAME], data=self._init_info) instruments = self._init_info["CONF_VEHICLES"][ self._init_info[CONF_VEHICLE]] instruments_dict = { instrument.attr: instrument.name for instrument in instruments } return self.async_show_form( step_id="select_instruments", errors=self._errors, data_schema=vol.Schema({ vol.Optional(CONF_RESOURCES, default=list(instruments_dict.keys())): cv.multi_select(instruments_dict) }), )
async def async_step_user(self, user_input=None): if user_input: return self.async_create_entry(title='', data=user_input) host = self.entry.options['host'] token = self.entry.options['token'] ble = self.entry.options.get('ble', True) stats = self.entry.options.get('stats', False) debug = self.entry.options.get('debug', []) buzzer = self.entry.options.get('buzzer', False) parent = self.entry.options.get('parent') zha = self.entry.options.get('zha', False) return self.async_show_form( step_id="user", data_schema=vol.Schema({ vol.Required('host', default=host): str, vol.Required('token', default=token): str, vol.Required('ble', default=ble): bool, vol.Required('stats', default=stats): bool, vol.Optional('debug', default=debug): cv.multi_select(OPT_DEBUG), vol.Optional('buzzer', default=buzzer): bool, vol.Optional('parent', default=parent): vol.In(OPT_PARENT), vol.Required('zha', default=zha): vol.In(OPT_MODE), }), )
async def async_step_simple_options(self, user_input=None): """For users without advanced settings enabled.""" if user_input is not None: self.options.update(user_input) return await self._update_options() clients_to_block = {} for client in self.controller.api.clients.values(): clients_to_block[ client. mac] = f"{client.name or client.hostname} ({client.mac})" return self.async_show_form( step_id="simple_options", data_schema=vol.Schema({ vol.Optional( CONF_TRACK_CLIENTS, default=self.controller.option_track_clients, ): bool, vol.Optional( CONF_TRACK_DEVICES, default=self.controller.option_track_devices, ): bool, vol.Optional(CONF_BLOCK_CLIENT, default=self.options[CONF_BLOCK_CLIENT]): cv.multi_select(clients_to_block), }), )
async def async_step_client_control(self, user_input=None): """Manage configuration of network access controlled clients.""" errors = {} if user_input is not None: self.options.update(user_input) return await self.async_step_statistics_sensors() clients_to_block = {} for client in self.controller.api.clients.values(): clients_to_block[ client. mac] = f"{client.name or client.hostname} ({client.mac})" return self.async_show_form( step_id="client_control", data_schema=vol.Schema({ vol.Optional(CONF_BLOCK_CLIENT, default=self.options[CONF_BLOCK_CLIENT]): cv.multi_select(clients_to_block), vol.Optional( CONF_POE_CLIENTS, default=self.options.get(CONF_POE_CLIENTS, DEFAULT_POE_CLIENTS), ): bool, vol.Optional( CONF_DPI_RESTRICTIONS, default=self.options.get(CONF_DPI_RESTRICTIONS, DEFAULT_DPI_RESTRICTIONS), ): bool, }), errors=errors, )
async def async_step_systems(self, user_input=None): """Configure selected systems.""" if user_input is not None: self.user_data[CONF_SYSTEMS] = { key: {} for key in user_input[CONF_SYSTEMS] } return self.async_create_entry(title="", data=self.user_data) systems = await self.uplink.get_systems() systems_dict = { str(x["systemId"]): f"{x['name']} ({x['productName']})" for x in systems } systems_sel = list(systems_dict.keys()) return self.async_show_form( step_id="systems", description_placeholders={}, data_schema=vol.Schema({ vol.Required(CONF_SYSTEMS, default=systems_sel): cv.multi_select(systems_dict) }), )
async def async_step_init(self, user_input: dict[str, Any] | None = None ) -> FlowResult: """Manage the options.""" errors = {} if user_input is not None: options_input = {CONF_SOURCES: user_input[CONF_SOURCES]} return self.async_create_entry(title="", data=options_input) # Get sources sources_list = await async_get_sources(self.host, self.key) if not sources_list: errors["base"] = "cannot_retrieve" sources = [ s for s in self.options.get(CONF_SOURCES, []) if s in sources_list ] if not sources: sources = sources_list options_schema = vol.Schema({ vol.Optional( CONF_SOURCES, description={"suggested_value": sources}, ): cv.multi_select({source: source for source in sources_list}), }) return self.async_show_form(step_id="init", data_schema=options_schema, errors=errors)
async def async_step_init(self, user_input=None): """Handle options flow.""" if user_input is not None: return self.async_create_entry(title="", data=user_input) from pydigitalstrom import constants # build scene list for mutli select scenes = {} for scene_id, scene_name in constants.SCENE_NAMES.items(): scenes[scene_name] = scene_name scenes = sorted(scenes) # build options based on multi select options = { vol.Optional( OPTION_GENERIC_SCENES, default=self.config_entry.options.get( OPTION_GENERIC_SCENES, OPTION_GENERIC_SCENES_DEFAULT), ): config_validation.multi_select(scenes), } return self.async_show_form(step_id="init", data_schema=vol.Schema(options))
async def async_step_remove_devices( self, user_input: Optional[Dict[str, Any]] = None) -> Dict[str, Any]: """Handle the device removal step.""" errors: Dict[str, str] = {} assert self.hass is not None devices: List[DeviceEntry] = await self.hass.async_create_task( _get_devices(cast(HomeAssistant, self.hass), self.config_entry)) device_schema = vol.Schema({ vol.Optional(CONF_DEVICES, default=[]): cv.multi_select({d.id: d.name for d in devices}), }) if user_input is not None: ids = [id for id in user_input[CONF_DEVICES]] await self.hass.async_create_task( _remove_devices(cast(HomeAssistant, self.hass), ids)) return await self.async_step_override_lights() if len(errors) == 0: form_errors = None else: form_errors = errors return self.async_show_form( step_id=STEP_REMOVE_DEVICES, data_schema=device_schema, errors=form_errors, )
async def async_step_xiaoai( self, user_input=None, error=None): # 本地发现不了设备,需要手动输入model,输入后再修改mapping,params errors = {} if user_input is not None: self._input2 = {**self._input2, **user_input} self._model = user_input[CONF_MODEL] # Line 240-270 self._info = await guess_mp_from_model(self.hass, self._model) hint = "" if self._info and self._info.get('mapping') != "{}": hint += f"\n根据 model (**{self._model}**),已经自动发现配置参数。\n如无特殊需要,无需修改下列内容。\n" devtype_default = self._info.get('device_type') mp = self._info.get('mapping') prm = self._info.get('params') mapping_default = mp params_default = prm else: hint += f"很抱歉,未能自动发现配置参数。但这不代表您的设备不受支持。\n您可以[手工编写配置](https://github.com/ha0y/xiaomi_miot_raw/#文件配置法),或者将型号 **{self._model}** 报告给作者。" devtype_default = [] mapping_default = '{"switch":{"switch_status":{"siid":2,"piid":1}}}' params_default = '{"switch":{"switch_status":{"power_on":true,"power_off":false}}}' if not self._non_interactive: return self.async_show_form( step_id="devinfo", data_schema=vol.Schema({ vol.Required('devtype', default=devtype_default): cv.multi_select(SUPPORTED_DOMAINS), vol.Required(CONF_MAPPING, default=mapping_default): str, vol.Required(CONF_CONTROL_PARAMS, default=params_default): str, vol.Optional('cloud_read', default=True): bool, vol.Optional('cloud_write', default=True): bool, }), description_placeholders={"device_info": hint}, errors=errors, ) else: return await self.async_step_devinfo({ 'devtype': devtype_default, CONF_MAPPING: mapping_default, CONF_CONTROL_PARAMS: params_default, 'cloud_read': True, 'cloud_write': True, }) return self.async_show_form(step_id='xiaoai', data_schema=vol.Schema({ vol.Required(CONF_MODEL, default=self._model): str, }), errors={'base': 'no_connect_warning'})
async def async_step_remove_devices(self, user_input: Optional[Dict[str, Any]] = None ) -> FlowResult: """Handle the device removal step.""" errors: Dict[str, str] = {} assert self.hass is not None devices = _get_devices(self.hass, self.config_entry) device_map = {d.id: d.name for d in devices} device_schema = vol.Schema({ vol.Optional(CONF_DEVICES, default=[]): cv.multi_select(device_map), }) if user_input is not None: ids = [id for id in user_input[CONF_DEVICES]] _remove_devices(self.hass, ids) return await self.async_step_override_lights() if len(errors) == 0: form_errors = None else: form_errors = errors return self.async_show_form( step_id=STEP_REMOVE_DEVICES, data_schema=device_schema, errors=form_errors, )
async def async_step_select_devices(self, user_input=None): errors = {} if user_input is not None: for device in user_input['devices']: self.hass.async_add_job( self.hass.config_entries.flow.async_init( DOMAIN, context={"source": "batch_add"}, data={'did': device})) return self.async_create_entry(title="", data=None) devlist = {} for device in self.hass.data[DOMAIN]['micloud_devices']: if device['did'] not in devlist: dt = get_conn_type(device) dt = "WiFi" if dt == 0 else "ZigBee" if dt == 1 else "BLE" if dt == 2 \ else "BLE Mesh" if dt == 3 else "Unknown" name = f"{device['name']} ({dt}{', '+device['localip'] if (dt == '''WiFi''') else ''})" devlist[device['did']] = name return self.async_show_form( step_id='select_devices', data_schema=vol.Schema({ vol.Required('devices', default=[]): cv.multi_select(devlist), }), errors=errors, )
async def async_step_public_weather_areas(self, user_input=None): """Manage configuration of Netatmo public weather areas.""" errors = {} if user_input is not None: new_client = user_input.pop(CONF_NEW_AREA, None) areas = user_input.pop(CONF_WEATHER_AREAS, None) user_input[CONF_WEATHER_AREAS] = { area: self.options[CONF_WEATHER_AREAS][area] for area in areas } self.options.update(user_input) if new_client: return await self.async_step_public_weather( user_input={CONF_NEW_AREA: new_client}) return self._create_options_entry() weather_areas = list(self.options[CONF_WEATHER_AREAS]) data_schema = vol.Schema({ vol.Optional( CONF_WEATHER_AREAS, default=weather_areas, ): cv.multi_select(weather_areas), vol.Optional(CONF_NEW_AREA): str, }) return self.async_show_form( step_id="public_weather_areas", data_schema=data_schema, errors=errors, )
async def async_step_init(self, user_input=None): """Handle options flow.""" conf = self.config_entry if conf.source == config_entries.SOURCE_IMPORT: return self.async_show_form(step_id="init", data_schema={}) errors = {} if user_input is not None: validate_options(user_input, errors) if not errors: return self.async_create_entry(title="", data=user_input) all_lights = [ light for light in self.hass.states.async_entity_ids("light") if _supported_features(self.hass, light) ] to_replace = {CONF_LIGHTS: cv.multi_select(sorted(all_lights))} options_schema = {} for name, default, validation in VALIDATION_TUPLES: key = vol.Optional(name, default=conf.options.get(name, default)) value = to_replace.get(name, validation) options_schema[key] = value return self.async_show_form(step_id="init", data_schema=vol.Schema(options_schema), errors=errors)
async def async_step_robots(self, user_input=None): """Handle the robots selection step.""" errors = {} if user_input is not None: try: if len(user_input[CONF_DEVICEID]) < 1: errors["base"] = "select_robots" else: self.data[CONF_DEVICEID] = user_input return self.async_create_entry( title=self.data[CONF_USERNAME], data=self.data) except Exception: _LOGGER.exception("Unexpected exception") errors["base"] = "unknown" # If there is no user input or there were errors, show the form again, including any errors that were found with the input. robot_listDict = {e["name"]: e["nick"] for e in self.robot_list} options_schema = vol.Schema({ vol.Required(CONF_DEVICEID, default=list(robot_listDict.keys())): cv.multi_select(robot_listDict) }) return self.async_show_form(step_id="robots", data_schema=options_schema, errors=errors)
async def async_step_user(self, user_input=None): """Handle the initial step.""" errors = {} if user_input is not None: port = await self._async_available_port() name = self._async_available_name() title = f"{name}:{port}" self.homekit_data = user_input.copy() self.homekit_data[CONF_NAME] = name self.homekit_data[CONF_PORT] = port self.homekit_data[CONF_FILTER] = { CONF_INCLUDE_DOMAINS: user_input[CONF_INCLUDE_DOMAINS], CONF_INCLUDE_ENTITIES: [], CONF_EXCLUDE_DOMAINS: [], CONF_EXCLUDE_ENTITIES: [], } del self.homekit_data[CONF_INCLUDE_DOMAINS] self.entry_title = title return await self.async_step_pairing() default_domains = [] if self._async_current_entries( ) else DEFAULT_DOMAINS setup_schema = vol.Schema({ vol.Optional(CONF_AUTO_START, default=DEFAULT_AUTO_START): bool, vol.Required(CONF_INCLUDE_DOMAINS, default=default_domains): cv.multi_select(SUPPORTED_DOMAINS), }) return self.async_show_form(step_id="user", data_schema=setup_schema, errors=errors)
async def async_step_include(self, user_input=None): """Choose entities to include from the domain on the bridge.""" domains = self.hk_options[CONF_DOMAINS] if user_input is not None: entities = cv.ensure_list(user_input[CONF_ENTITIES]) entity_filter = _async_build_entites_filter(domains, entities) self.included_cameras = _async_cameras_from_entities(entities) self.hk_options[CONF_FILTER] = entity_filter if self.included_cameras: return await self.async_step_cameras() return await self.async_step_advanced() entity_filter = self.hk_options.get(CONF_FILTER, {}) entities = entity_filter.get(CONF_INCLUDE_ENTITIES, []) all_supported_entities = _async_get_matching_entities( self.hass, domains) if not entities: entities = entity_filter.get(CONF_EXCLUDE_ENTITIES, []) # Strip out entities that no longer exist to prevent error in the UI default_value = [ entity_id for entity_id in entities if entity_id in all_supported_entities ] return self.async_show_form( step_id="include", description_placeholders={ "domains": await _async_domain_names(self.hass, domains) }, data_schema=vol.Schema({ vol.Optional(CONF_ENTITIES, default=default_value): cv.multi_select(all_supported_entities) }), )
async def async_step_select_devices(self, user_input=None): errors = {} if user_input is not None: for device in user_input['devices']: self.hass.async_add_job(self.hass.config_entries.flow.async_init( DOMAIN, context={"source": "batch_add"}, data={'did': device} )) return self.async_abort(reason="success") devlist = {} while not self.hass.data[DOMAIN]['micloud_devices']: await asyncio.sleep(1) for device in self.hass.data[DOMAIN]['micloud_devices']: if device['did'] not in devlist: dt = get_conn_type(device) dt = "WiFi" if dt == 0 else "ZigBee" if dt == 1 else "BLE" if dt == 2 \ else "BLE Mesh" if dt == 3 else "InfraRed" if dt == 4 else "Unknown" name = f"{device['name']} ({dt}{', '+device['localip'] if (dt == '''WiFi''') else ''})" devlist[device['did']] = name return self.async_show_form( step_id='select_devices', data_schema=vol.Schema({ vol.Required('devices', default=[]): cv.multi_select(devlist), }), description_placeholders={"dev_count": str(len(devlist))}, errors=errors, )
async def async_step_init( self, user_input: dict[str, Any] | None = None, ) -> FlowResult: """Handle options flow.""" if not user_input: configured_repositories: list[str] = self.config_entry.options[ CONF_REPOSITORIES ] repositories = await get_repositories( self.hass, self.config_entry.data[CONF_ACCESS_TOKEN] ) # In case the user has removed a starred repository that is already tracked for repository in configured_repositories: if repository not in repositories: repositories.append(repository) return self.async_show_form( step_id="init", data_schema=vol.Schema( { vol.Required( CONF_REPOSITORIES, default=configured_repositories, ): cv.multi_select({k: k for k in repositories}), } ), ) return self.async_create_entry(title="", data=user_input)
async def async_step_cameras(self, user_input=None): """Choose camera config.""" if user_input is not None: entity_config = self.hk_options[CONF_ENTITY_CONFIG] for entity_id in self.included_cameras: if entity_id in user_input[CONF_CAMERA_COPY]: entity_config.setdefault( entity_id, {})[CONF_VIDEO_CODEC] = VIDEO_CODEC_COPY elif (entity_id in entity_config and CONF_VIDEO_CODEC in entity_config[entity_id]): del entity_config[entity_id][CONF_VIDEO_CODEC] return await self.async_step_advanced() cameras_with_copy = [] entity_config = self.hk_options.setdefault(CONF_ENTITY_CONFIG, {}) for entity in self.included_cameras: hk_entity_config = entity_config.get(entity, {}) if hk_entity_config.get(CONF_VIDEO_CODEC) == VIDEO_CODEC_COPY: cameras_with_copy.append(entity) data_schema = vol.Schema({ vol.Optional( CONF_CAMERA_COPY, default=cameras_with_copy, ): cv.multi_select(self.included_cameras), }) return self.async_show_form(step_id="cameras", data_schema=data_schema)
async def async_step_include_domains( self, user_input: ConfigType | None = None ) -> data_entry_flow.FlowResult: yaml_config = await async_integration_yaml_config(self.hass, DOMAIN) if DOMAIN in yaml_config and not is_config_filter_empty( yaml_config[DOMAIN]): return await self.async_step_include_domains_yaml() if user_input is not None: self._options.update(user_input) return await self.async_step_include_exclude() entity_filter = self._options.get(const.CONF_FILTER, {}) domains = entity_filter.get(CONF_INCLUDE_DOMAINS, []) include_entities = entity_filter.get(CONF_INCLUDE_ENTITIES) if include_entities: domains.extend(_domains_set_from_entities(include_entities)) name_to_type_map = await _async_name_to_type_map(self.hass) return self.async_show_form( step_id='include_domains', data_schema=vol.Schema({ vol.Required(CONF_DOMAINS, default=sorted(set(domains))): cv.multi_select(name_to_type_map), }), )
async def async_step_cloud(self, user_input=None, error=None): if user_input: if not user_input['servers']: return await self.async_step_cloud(error='no_servers') session = async_create_clientsession(self.hass) cloud = MiCloud(session) if await cloud.login(user_input['username'], user_input['password']): user_input.update(cloud.auth) return self.async_create_entry(title=user_input['username'], data=user_input) else: return await self.async_step_cloud(error='cant_login') return self.async_show_form( step_id='cloud', data_schema=vol.Schema({ vol.Required('username'): str, vol.Required('password'): str, vol.Required('servers', default=['cn']): cv.multi_select(SERVERS) }), errors={'base': error} if error else None )
async def async_step_init(self, user_input=None): """Handle options flow.""" if self.config_entry.source == SOURCE_IMPORT: return await self.async_step_yaml(user_input) if user_input is not None: self.hk_options.update(user_input) return await self.async_step_include_exclude() self.hk_options = dict(self.config_entry.options) entity_filter = self.hk_options.get(CONF_FILTER, {}) homekit_mode = self.hk_options.get(CONF_HOMEKIT_MODE, DEFAULT_HOMEKIT_MODE) domains = entity_filter.get(CONF_INCLUDE_DOMAINS, []) include_entities = entity_filter.get(CONF_INCLUDE_ENTITIES) if include_entities: domains.extend(_domains_set_from_entities(include_entities)) name_to_type_map = await _async_name_to_type_map(self.hass) return self.async_show_form( step_id="init", data_schema=vol.Schema( { vol.Required(CONF_HOMEKIT_MODE, default=homekit_mode): vol.In( HOMEKIT_MODES ), vol.Required( CONF_DOMAINS, default=domains, ): cv.multi_select(name_to_type_map), } ), )
async def async_step_init(self, user_input=None): """Manage options.""" if user_input is not None: if not is_ip_address(user_input.get(CONF_HOST)): return self.async_abort(reason="connection_error") self._host = user_input.get(CONF_HOST) if len(user_input.get(CONF_PASSWORD, "")) >= 1: self._password = user_input.get(CONF_PASSWORD) return self.async_create_entry( title='', data={ CONF_HOST: self._host, CONF_PASSWORD: self._password, CONF_MODEL: self._model }, ) self._host = self.config_entry.options[CONF_HOST] self._password = self.config_entry.options[CONF_PASSWORD] self._model = self.config_entry.options.get(CONF_MODEL, '') debug = self.config_entry.options.get(CONF_DEBUG, []) return self.async_show_form( step_id="init", data_schema=vol.Schema({ vol.Required(CONF_HOST, default=self._host): str, vol.Optional(CONF_PASSWORD, default=self._password): str, vol.Optional(CONF_MODEL): vol.In(OPT_DEVICE_NAME), vol.Optional(CONF_DEBUG, default=debug): cv.multi_select(OPT_DEBUG), }), )