evlli/hass-core
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Migrate integrations u-z to generic flowhandler (#111866)

Browse source
This commit is contained in:
Erik Montnemery 2024-02-29 20:08:16 +01:00 • committed by GitHub
parent e06446d0fa
commit 9ec9ac4fd4
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
64 changed files with 577 additions and 454 deletions
Download patch file Download diff file Expand all files Collapse all files

4
homeassistant/components/ukraine_alarm/config_flow.py
View file

@ -7,7 +7,7 @@ import aiohttp
from uasiren.client import Client from uasiren.client import Client
import voluptuous as vol import voluptuous as vol
from homeassistant import config_entries from homeassistant.config_entries import ConfigFlow
from homeassistant.const import CONF_NAME, CONF_REGION from homeassistant.const import CONF_NAME, CONF_REGION
from homeassistant.helpers.aiohttp_client import async_get_clientsession from homeassistant.helpers.aiohttp_client import async_get_clientsession
@ -16,7 +16,7 @@ from .const import DOMAIN
_LOGGER = logging.getLogger(__name__) _LOGGER = logging.getLogger(__name__)
class UkraineAlarmConfigFlow(config_entries.ConfigFlow, domain=DOMAIN): class UkraineAlarmConfigFlow(ConfigFlow, domain=DOMAIN):
"""Config flow for Ukraine Alarm.""" """Config flow for Ukraine Alarm."""
VERSION = 1 VERSION = 1

44
homeassistant/components/unifi/config_flow.py
View file

@ -17,8 +17,13 @@ from urllib.parse import urlparse
from aiounifi.interfaces.sites import Sites from aiounifi.interfaces.sites import Sites
import voluptuous as vol import voluptuous as vol
from homeassistant import config_entries
from homeassistant.components import ssdp from homeassistant.components import ssdp
from homeassistant.config_entries import (
ConfigEntry,
ConfigFlow,
ConfigFlowResult,
OptionsFlow,
)
from homeassistant.const import ( from homeassistant.const import (
CONF_HOST, CONF_HOST,
CONF_PASSWORD, CONF_PASSWORD,
@ -27,7 +32,6 @@ from homeassistant.const import (
CONF_VERIFY_SSL, CONF_VERIFY_SSL,
) )
from homeassistant.core import HomeAssistant, callback from homeassistant.core import HomeAssistant, callback
from homeassistant.data_entry_flow import FlowResult
import homeassistant.helpers.config_validation as cv import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.device_registry import format_mac from homeassistant.helpers.device_registry import format_mac
@ -61,7 +65,7 @@ MODEL_PORTS = {
} }
class UnifiFlowHandler(config_entries.ConfigFlow, domain=UNIFI_DOMAIN): class UnifiFlowHandler(ConfigFlow, domain=UNIFI_DOMAIN):
"""Handle a UniFi Network config flow.""" """Handle a UniFi Network config flow."""
VERSION = 1 VERSION = 1
@ -71,7 +75,7 @@ class UnifiFlowHandler(config_entries.ConfigFlow, domain=UNIFI_DOMAIN):
@staticmethod @staticmethod
@callback @callback
def async_get_options_flow( def async_get_options_flow(
config_entry: config_entries.ConfigEntry, config_entry: ConfigEntry,
) -> UnifiOptionsFlowHandler: ) -> UnifiOptionsFlowHandler:
"""Get the options flow for this handler.""" """Get the options flow for this handler."""
return UnifiOptionsFlowHandler(config_entry) return UnifiOptionsFlowHandler(config_entry)
@ -79,12 +83,12 @@ class UnifiFlowHandler(config_entries.ConfigFlow, domain=UNIFI_DOMAIN):
def __init__(self) -> None: def __init__(self) -> None:
"""Initialize the UniFi Network flow.""" """Initialize the UniFi Network flow."""
self.config: dict[str, Any] = {} self.config: dict[str, Any] = {}
self.reauth_config_entry: config_entries.ConfigEntry | None = None self.reauth_config_entry: ConfigEntry | None = None
self.reauth_schema: dict[vol.Marker, Any] = {} self.reauth_schema: dict[vol.Marker, Any] = {}
async def async_step_user( async def async_step_user(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle a flow initialized by the user.""" """Handle a flow initialized by the user."""
errors = {} errors = {}
@ -144,7 +148,7 @@ class UnifiFlowHandler(config_entries.ConfigFlow, domain=UNIFI_DOMAIN):
async def async_step_site( async def async_step_site(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Select site to control.""" """Select site to control."""
if user_input is not None: if user_input is not None:
unique_id = user_input[CONF_SITE_ID] unique_id = user_input[CONF_SITE_ID]
@ -181,7 +185,9 @@ class UnifiFlowHandler(config_entries.ConfigFlow, domain=UNIFI_DOMAIN):
data_schema=vol.Schema({vol.Required(CONF_SITE_ID): vol.In(site_names)}), data_schema=vol.Schema({vol.Required(CONF_SITE_ID): vol.In(site_names)}),
) )
async def async_step_reauth(self, entry_data: Mapping[str, Any]) -> FlowResult: async def async_step_reauth(
self, entry_data: Mapping[str, Any]
) -> ConfigFlowResult:
"""Trigger a reauthentication flow.""" """Trigger a reauthentication flow."""
config_entry = self.hass.config_entries.async_get_entry( config_entry = self.hass.config_entries.async_get_entry(
self.context["entry_id"] self.context["entry_id"]
@ -206,7 +212,9 @@ class UnifiFlowHandler(config_entries.ConfigFlow, domain=UNIFI_DOMAIN):
return await self.async_step_user() return await self.async_step_user()
async def async_step_ssdp(self, discovery_info: ssdp.SsdpServiceInfo) -> FlowResult: async def async_step_ssdp(
self, discovery_info: ssdp.SsdpServiceInfo
) -> ConfigFlowResult:
"""Handle a discovered UniFi device.""" """Handle a discovered UniFi device."""
parsed_url = urlparse(discovery_info.ssdp_location) parsed_url = urlparse(discovery_info.ssdp_location)
model_description = discovery_info.upnp[ssdp.ATTR_UPNP_MODEL_DESCRIPTION] model_description = discovery_info.upnp[ssdp.ATTR_UPNP_MODEL_DESCRIPTION]
@ -235,19 +243,19 @@ class UnifiFlowHandler(config_entries.ConfigFlow, domain=UNIFI_DOMAIN):
return await self.async_step_user() return await self.async_step_user()
class UnifiOptionsFlowHandler(config_entries.OptionsFlow): class UnifiOptionsFlowHandler(OptionsFlow):
"""Handle Unifi Network options.""" """Handle Unifi Network options."""
hub: UnifiHub hub: UnifiHub
def __init__(self, config_entry: config_entries.ConfigEntry) -> None: def __init__(self, config_entry: ConfigEntry) -> None:
"""Initialize UniFi Network options flow.""" """Initialize UniFi Network options flow."""
self.config_entry = config_entry self.config_entry = config_entry
self.options = dict(config_entry.options) self.options = dict(config_entry.options)
async def async_step_init( async def async_step_init(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Manage the UniFi Network options.""" """Manage the UniFi Network options."""
if self.config_entry.entry_id not in self.hass.data[UNIFI_DOMAIN]: if self.config_entry.entry_id not in self.hass.data[UNIFI_DOMAIN]:
return self.async_abort(reason="integration_not_setup") return self.async_abort(reason="integration_not_setup")
@ -261,7 +269,7 @@ class UnifiOptionsFlowHandler(config_entries.OptionsFlow):
async def async_step_simple_options( async def async_step_simple_options(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""For users without advanced settings enabled.""" """For users without advanced settings enabled."""
if user_input is not None: if user_input is not None:
self.options.update(user_input) self.options.update(user_input)
@ -296,7 +304,7 @@ class UnifiOptionsFlowHandler(config_entries.OptionsFlow):
async def async_step_configure_entity_sources( async def async_step_configure_entity_sources(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Select sources for entities.""" """Select sources for entities."""
if user_input is not None: if user_input is not None:
self.options.update(user_input) self.options.update(user_input)
@ -329,7 +337,7 @@ class UnifiOptionsFlowHandler(config_entries.OptionsFlow):
async def async_step_device_tracker( async def async_step_device_tracker(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Manage the device tracker options.""" """Manage the device tracker options."""
if user_input is not None: if user_input is not None:
self.options.update(user_input) self.options.update(user_input)
@ -390,7 +398,7 @@ class UnifiOptionsFlowHandler(config_entries.OptionsFlow):
async def async_step_client_control( async def async_step_client_control(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Manage configuration of network access controlled clients.""" """Manage configuration of network access controlled clients."""
if user_input is not None: if user_input is not None:
self.options.update(user_input) self.options.update(user_input)
@ -429,7 +437,7 @@ class UnifiOptionsFlowHandler(config_entries.OptionsFlow):
async def async_step_statistics_sensors( async def async_step_statistics_sensors(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Manage the statistics sensors options.""" """Manage the statistics sensors options."""
if user_input is not None: if user_input is not None:
self.options.update(user_input) self.options.update(user_input)
@ -452,7 +460,7 @@ class UnifiOptionsFlowHandler(config_entries.OptionsFlow):
last_step=True, last_step=True,
) )
async def _update_options(self) -> FlowResult: async def _update_options(self) -> ConfigFlowResult:
"""Update config entry options.""" """Update config entry options."""
return self.async_create_entry(title="", data=self.options) return self.async_create_entry(title="", data=self.options)

56
homeassistant/components/unifiprotect/config_flow.py
View file

@ -13,8 +13,15 @@ from pyunifiprotect.exceptions import ClientError, NotAuthorized
from unifi_discovery import async_console_is_alive from unifi_discovery import async_console_is_alive
import voluptuous as vol import voluptuous as vol
from homeassistant import config_entries
from homeassistant.components import dhcp, ssdp from homeassistant.components import dhcp, ssdp
from homeassistant.config_entries import (
SOURCE_IGNORE,
ConfigEntry,
ConfigEntryState,
ConfigFlow,
ConfigFlowResult,
OptionsFlow,
)
from homeassistant.const import ( from homeassistant.const import (
CONF_HOST, CONF_HOST,
CONF_ID, CONF_ID,
@ -24,7 +31,6 @@ from homeassistant.const import (
CONF_VERIFY_SSL, CONF_VERIFY_SSL,
) )
from homeassistant.core import HomeAssistant, callback from homeassistant.core import HomeAssistant, callback
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers.aiohttp_client import ( from homeassistant.helpers.aiohttp_client import (
async_create_clientsession, async_create_clientsession,
async_get_clientsession, async_get_clientsession,
@ -54,8 +60,8 @@ from .utils import _async_resolve, _async_short_mac, _async_unifi_mac_from_hass
_LOGGER = logging.getLogger(__name__) _LOGGER = logging.getLogger(__name__)
ENTRY_FAILURE_STATES = ( ENTRY_FAILURE_STATES = (
config_entries.ConfigEntryState.SETUP_ERROR, ConfigEntryState.SETUP_ERROR,
config_entries.ConfigEntryState.SETUP_RETRY, ConfigEntryState.SETUP_RETRY,
) )
@ -72,7 +78,7 @@ def _host_is_direct_connect(host: str) -> bool:
async def _async_console_is_offline( async def _async_console_is_offline(
hass: HomeAssistant, hass: HomeAssistant,
entry: config_entries.ConfigEntry, entry: ConfigEntry,
) -> bool: ) -> bool:
"""Check if a console is offline. """Check if a console is offline.
@ -89,7 +95,7 @@ async def _async_console_is_offline(
) )
class ProtectFlowHandler(config_entries.ConfigFlow, domain=DOMAIN): class ProtectFlowHandler(ConfigFlow, domain=DOMAIN):
"""Handle a UniFi Protect config flow.""" """Handle a UniFi Protect config flow."""
VERSION = 2 VERSION = 2
@ -97,20 +103,24 @@ class ProtectFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
def __init__(self) -> None: def __init__(self) -> None:
"""Init the config flow.""" """Init the config flow."""
super().__init__() super().__init__()
self.entry: config_entries.ConfigEntry | None = None self.entry: ConfigEntry | None = None
self._discovered_device: dict[str, str] = {} self._discovered_device: dict[str, str] = {}
async def async_step_dhcp(self, discovery_info: dhcp.DhcpServiceInfo) -> FlowResult: async def async_step_dhcp(
self, discovery_info: dhcp.DhcpServiceInfo
) -> ConfigFlowResult:
"""Handle discovery via dhcp.""" """Handle discovery via dhcp."""
_LOGGER.debug("Starting discovery via: %s", discovery_info) _LOGGER.debug("Starting discovery via: %s", discovery_info)
return await self._async_discovery_handoff() return await self._async_discovery_handoff()
async def async_step_ssdp(self, discovery_info: ssdp.SsdpServiceInfo) -> FlowResult: async def async_step_ssdp(
self, discovery_info: ssdp.SsdpServiceInfo
) -> ConfigFlowResult:
"""Handle a discovered UniFi device.""" """Handle a discovered UniFi device."""
_LOGGER.debug("Starting discovery via: %s", discovery_info) _LOGGER.debug("Starting discovery via: %s", discovery_info)
return await self._async_discovery_handoff() return await self._async_discovery_handoff()
async def _async_discovery_handoff(self) -> FlowResult: async def _async_discovery_handoff(self) -> ConfigFlowResult:
"""Ensure discovery is active.""" """Ensure discovery is active."""
# Discovery requires an additional check so we use # Discovery requires an additional check so we use
# SSDP and DHCP to tell us to start it so it only # SSDP and DHCP to tell us to start it so it only
@ -120,7 +130,7 @@ class ProtectFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_integration_discovery( async def async_step_integration_discovery(
self, discovery_info: DiscoveryInfoType self, discovery_info: DiscoveryInfoType
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle integration discovery.""" """Handle integration discovery."""
self._discovered_device = discovery_info self._discovered_device = discovery_info
mac = _async_unifi_mac_from_hass(discovery_info["hw_addr"]) mac = _async_unifi_mac_from_hass(discovery_info["hw_addr"])
@ -128,7 +138,7 @@ class ProtectFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
source_ip = discovery_info["source_ip"] source_ip = discovery_info["source_ip"]
direct_connect_domain = discovery_info["direct_connect_domain"] direct_connect_domain = discovery_info["direct_connect_domain"]
for entry in self._async_current_entries(): for entry in self._async_current_entries():
if entry.source == config_entries.SOURCE_IGNORE: if entry.source == SOURCE_IGNORE:
if entry.unique_id == mac: if entry.unique_id == mac:
return self.async_abort(reason="already_configured") return self.async_abort(reason="already_configured")
continue continue
@ -164,7 +174,7 @@ class ProtectFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_discovery_confirm( async def async_step_discovery_confirm(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Confirm discovery.""" """Confirm discovery."""
errors: dict[str, str] = {} errors: dict[str, str] = {}
discovery_info = self._discovered_device discovery_info = self._discovered_device
@ -212,13 +222,13 @@ class ProtectFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
@staticmethod @staticmethod
@callback @callback
def async_get_options_flow( def async_get_options_flow(
config_entry: config_entries.ConfigEntry, config_entry: ConfigEntry,
) -> config_entries.OptionsFlow: ) -> OptionsFlow:
"""Get the options flow for this handler.""" """Get the options flow for this handler."""
return OptionsFlowHandler(config_entry) return OptionsFlowHandler(config_entry)
@callback @callback
def _async_create_entry(self, title: str, data: dict[str, Any]) -> FlowResult: def _async_create_entry(self, title: str, data: dict[str, Any]) -> ConfigFlowResult:
return self.async_create_entry( return self.async_create_entry(
title=title, title=title,
data={**data, CONF_ID: title}, data={**data, CONF_ID: title},
@ -279,7 +289,9 @@ class ProtectFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
return nvr_data, errors return nvr_data, errors
async def async_step_reauth(self, entry_data: Mapping[str, Any]) -> FlowResult: async def async_step_reauth(
self, entry_data: Mapping[str, Any]
) -> ConfigFlowResult:
"""Perform reauth upon an API authentication error.""" """Perform reauth upon an API authentication error."""
self.entry = self.hass.config_entries.async_get_entry(self.context["entry_id"]) self.entry = self.hass.config_entries.async_get_entry(self.context["entry_id"])
@ -287,7 +299,7 @@ class ProtectFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_reauth_confirm( async def async_step_reauth_confirm(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Confirm reauth.""" """Confirm reauth."""
errors: dict[str, str] = {} errors: dict[str, str] = {}
assert self.entry is not None assert self.entry is not None
@ -321,7 +333,7 @@ class ProtectFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user( async def async_step_user(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle a flow initiated by the user.""" """Handle a flow initiated by the user."""
errors: dict[str, str] = {} errors: dict[str, str] = {}
@ -362,16 +374,16 @@ class ProtectFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
) )
class OptionsFlowHandler(config_entries.OptionsFlow): class OptionsFlowHandler(OptionsFlow):
"""Handle options.""" """Handle options."""
def __init__(self, config_entry: config_entries.ConfigEntry) -> None: def __init__(self, config_entry: ConfigEntry) -> None:
"""Initialize options flow.""" """Initialize options flow."""
self.config_entry = config_entry self.config_entry = config_entry
async def async_step_init( async def async_step_init(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Manage the options.""" """Manage the options."""
if user_input is not None: if user_input is not None:
return self.async_create_entry(title="", data=user_input) return self.async_create_entry(title="", data=user_input)

9
homeassistant/components/upb/config_flow.py
View file

@ -7,8 +7,9 @@ from urllib.parse import urlparse
import upb_lib import upb_lib
import voluptuous as vol import voluptuous as vol
from homeassistant import config_entries, exceptions from homeassistant.config_entries import ConfigFlow
from homeassistant.const import CONF_ADDRESS, CONF_FILE_PATH, CONF_HOST, CONF_PROTOCOL from homeassistant.const import CONF_ADDRESS, CONF_FILE_PATH, CONF_HOST, CONF_PROTOCOL
from homeassistant.exceptions import HomeAssistantError
from .const import DOMAIN from .const import DOMAIN
@ -70,7 +71,7 @@ def _make_url_from_data(data):
return f"{protocol}{address}" return f"{protocol}{address}"
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN): class UPBConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for UPB PIM.""" """Handle a config flow for UPB PIM."""
VERSION = 1 VERSION = 1
@ -128,9 +129,9 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
return urlparse(url).hostname in existing_hosts return urlparse(url).hostname in existing_hosts
class CannotConnect(exceptions.HomeAssistantError): class CannotConnect(HomeAssistantError):
"""Error to indicate we cannot connect.""" """Error to indicate we cannot connect."""
class InvalidUpbFile(exceptions.HomeAssistantError): class InvalidUpbFile(HomeAssistantError):
"""Error to indicate there is invalid or missing UPB config file.""" """Error to indicate there is invalid or missing UPB config file."""

22
homeassistant/components/upcloud/config_flow.py
View file

@ -9,17 +9,21 @@ import requests.exceptions
import upcloud_api import upcloud_api
import voluptuous as vol import voluptuous as vol
from homeassistant import config_entries from homeassistant.config_entries import (
ConfigEntry,
ConfigFlow,
ConfigFlowResult,
OptionsFlow,
)
from homeassistant.const import CONF_PASSWORD, CONF_SCAN_INTERVAL, CONF_USERNAME from homeassistant.const import CONF_PASSWORD, CONF_SCAN_INTERVAL, CONF_USERNAME
from homeassistant.core import callback from homeassistant.core import callback
from homeassistant.data_entry_flow import FlowResult
from .const import DEFAULT_SCAN_INTERVAL, DOMAIN from .const import DEFAULT_SCAN_INTERVAL, DOMAIN
_LOGGER = logging.getLogger(__name__) _LOGGER = logging.getLogger(__name__)
class UpCloudConfigFlow(config_entries.ConfigFlow, domain=DOMAIN): class UpCloudConfigFlow(ConfigFlow, domain=DOMAIN):
"""UpCloud config flow.""" """UpCloud config flow."""
VERSION = 1 VERSION = 1
@ -29,7 +33,7 @@ class UpCloudConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user( async def async_step_user(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle user initiated flow.""" """Handle user initiated flow."""
if user_input is None: if user_input is None:
return self._async_show_form(step_id="user") return self._async_show_form(step_id="user")
@ -66,7 +70,7 @@ class UpCloudConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
step_id: str, step_id: str,
user_input: dict[str, Any] | None = None, user_input: dict[str, Any] | None = None,
errors: dict[str, str] | None = None, errors: dict[str, str] | None = None,
) -> FlowResult: ) -> ConfigFlowResult:
"""Show our form.""" """Show our form."""
if user_input is None: if user_input is None:
user_input = {} user_input = {}
@ -88,22 +92,22 @@ class UpCloudConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
@staticmethod @staticmethod
@callback @callback
def async_get_options_flow( def async_get_options_flow(
config_entry: config_entries.ConfigEntry, config_entry: ConfigEntry,
) -> UpCloudOptionsFlow: ) -> UpCloudOptionsFlow:
"""Get options flow.""" """Get options flow."""
return UpCloudOptionsFlow(config_entry) return UpCloudOptionsFlow(config_entry)
class UpCloudOptionsFlow(config_entries.OptionsFlow): class UpCloudOptionsFlow(OptionsFlow):
"""UpCloud options flow.""" """UpCloud options flow."""
def __init__(self, config_entry: config_entries.ConfigEntry) -> None: def __init__(self, config_entry: ConfigEntry) -> None:
"""Initialize options flow.""" """Initialize options flow."""
self.config_entry = config_entry self.config_entry = config_entry
async def async_step_init( async def async_step_init(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle options flow.""" """Handle options flow."""
if user_input is not None: if user_input is not None:

19
homeassistant/components/upnp/config_flow.py
View file

@ -7,11 +7,10 @@ from urllib.parse import urlparse
import voluptuous as vol import voluptuous as vol
from homeassistant import config_entries
from homeassistant.components import ssdp from homeassistant.components import ssdp
from homeassistant.components.ssdp import SsdpServiceInfo from homeassistant.components.ssdp import SsdpServiceInfo
from homeassistant.config_entries import SOURCE_IGNORE, ConfigFlow, ConfigFlowResult
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.data_entry_flow import FlowResult
from .const import ( from .const import (
CONFIG_ENTRY_HOST, CONFIG_ENTRY_HOST,
@ -74,7 +73,7 @@ def _is_igd_device(discovery_info: ssdp.SsdpServiceInfo) -> bool:
return root_device_info.get(ssdp.ATTR_UPNP_DEVICE_TYPE) in {ST_IGD_V1, ST_IGD_V2} return root_device_info.get(ssdp.ATTR_UPNP_DEVICE_TYPE) in {ST_IGD_V1, ST_IGD_V2}
class UpnpFlowHandler(config_entries.ConfigFlow, domain=DOMAIN): class UpnpFlowHandler(ConfigFlow, domain=DOMAIN):
"""Handle a UPnP/IGD config flow.""" """Handle a UPnP/IGD config flow."""
VERSION = 1 VERSION = 1
@ -100,7 +99,7 @@ class UpnpFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user( async def async_step_user(
self, user_input: Mapping[str, Any] | None = None self, user_input: Mapping[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle a flow start.""" """Handle a flow start."""
LOGGER.debug("async_step_user: user_input: %s", user_input) LOGGER.debug("async_step_user: user_input: %s", user_input)
@ -151,7 +150,9 @@ class UpnpFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
data_schema=data_schema, data_schema=data_schema,
) )
async def async_step_ssdp(self, discovery_info: ssdp.SsdpServiceInfo) -> FlowResult: async def async_step_ssdp(
self, discovery_info: ssdp.SsdpServiceInfo
) -> ConfigFlowResult:
"""Handle a discovered UPnP/IGD device. """Handle a discovered UPnP/IGD device.
This flow is triggered by the SSDP component. It will check if the This flow is triggered by the SSDP component. It will check if the
@ -201,7 +202,7 @@ class UpnpFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
# Check ssdp_st to prevent swapping between IGDv1 and IGDv2. # Check ssdp_st to prevent swapping between IGDv1 and IGDv2.
continue continue
if entry.source == config_entries.SOURCE_IGNORE: if entry.source == SOURCE_IGNORE:
# Host was already ignored. Don't update ignored entries. # Host was already ignored. Don't update ignored entries.
return self.async_abort(reason="discovery_ignored") return self.async_abort(reason="discovery_ignored")
@ -225,7 +226,7 @@ class UpnpFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_ssdp_confirm( async def async_step_ssdp_confirm(
self, user_input: Mapping[str, Any] | None = None self, user_input: Mapping[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Confirm integration via SSDP.""" """Confirm integration via SSDP."""
LOGGER.debug("async_step_ssdp_confirm: user_input: %s", user_input) LOGGER.debug("async_step_ssdp_confirm: user_input: %s", user_input)
if user_input is None: if user_input is None:
@ -235,7 +236,7 @@ class UpnpFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
discovery = self._remove_discovery(self.unique_id) discovery = self._remove_discovery(self.unique_id)
return await self._async_create_entry_from_discovery(discovery) return await self._async_create_entry_from_discovery(discovery)
async def async_step_ignore(self, user_input: dict[str, Any]) -> FlowResult: async def async_step_ignore(self, user_input: dict[str, Any]) -> ConfigFlowResult:
"""Ignore this config flow.""" """Ignore this config flow."""
usn = user_input["unique_id"] usn = user_input["unique_id"]
discovery = self._remove_discovery(usn) discovery = self._remove_discovery(usn)
@ -255,7 +256,7 @@ class UpnpFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def _async_create_entry_from_discovery( async def _async_create_entry_from_discovery(
self, self,
discovery: SsdpServiceInfo, discovery: SsdpServiceInfo,
) -> FlowResult: ) -> ConfigFlowResult:
"""Create an entry from discovery.""" """Create an entry from discovery."""
LOGGER.debug( LOGGER.debug(
"_async_create_entry_from_discovery: discovery: %s", "_async_create_entry_from_discovery: discovery: %s",

5
homeassistant/components/uptime/config_flow.py
View file

@ -5,8 +5,7 @@ from typing import Any
import voluptuous as vol import voluptuous as vol
from homeassistant.config_entries import ConfigFlow from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.data_entry_flow import FlowResult
from .const import DOMAIN from .const import DOMAIN
@ -18,7 +17,7 @@ class UptimeConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_user( async def async_step_user(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle a flow initialized by the user.""" """Handle a flow initialized by the user."""
if self._async_current_entries(): if self._async_current_entries():
return self.async_abort(reason="single_instance_allowed") return self.async_abort(reason="single_instance_allowed")

13
homeassistant/components/uptimerobot/config_flow.py
View file

@ -14,9 +14,8 @@ from pyuptimerobot import (
) )
import voluptuous as vol import voluptuous as vol
from homeassistant import config_entries from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_API_KEY from homeassistant.const import CONF_API_KEY
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers.aiohttp_client import async_get_clientsession from homeassistant.helpers.aiohttp_client import async_get_clientsession
from .const import API_ATTR_OK, DOMAIN, LOGGER from .const import API_ATTR_OK, DOMAIN, LOGGER
@ -24,7 +23,7 @@ from .const import API_ATTR_OK, DOMAIN, LOGGER
STEP_USER_DATA_SCHEMA = vol.Schema({vol.Required(CONF_API_KEY): str}) STEP_USER_DATA_SCHEMA = vol.Schema({vol.Required(CONF_API_KEY): str})
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN): class UptimeRobotConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for UptimeRobot.""" """Handle a config flow for UptimeRobot."""
VERSION = 1 VERSION = 1
@ -68,7 +67,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user( async def async_step_user(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle the initial step.""" """Handle the initial step."""
if user_input is None: if user_input is None:
return self.async_show_form( return self.async_show_form(
@ -85,13 +84,15 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
) )
async def async_step_reauth(self, entry_data: Mapping[str, Any]) -> FlowResult: async def async_step_reauth(
self, entry_data: Mapping[str, Any]
) -> ConfigFlowResult:
"""Return the reauth confirm step.""" """Return the reauth confirm step."""
return await self.async_step_reauth_confirm() return await self.async_step_reauth_confirm()
async def async_step_reauth_confirm( async def async_step_reauth_confirm(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Dialog that informs the user that reauth is required.""" """Dialog that informs the user that reauth is required."""
if user_input is None: if user_input is None:
return self.async_show_form( return self.async_show_form(

7
homeassistant/components/v2c/config_flow.py
View file

@ -8,9 +8,8 @@ from pytrydan import Trydan
from pytrydan.exceptions import TrydanError from pytrydan.exceptions import TrydanError
import voluptuous as vol import voluptuous as vol
from homeassistant import config_entries from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_HOST from homeassistant.const import CONF_HOST
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers.httpx_client import get_async_client from homeassistant.helpers.httpx_client import get_async_client
from .const import DOMAIN from .const import DOMAIN
@ -24,14 +23,14 @@ STEP_USER_DATA_SCHEMA = vol.Schema(
) )
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN): class V2CConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for V2C.""" """Handle a config flow for V2C."""
VERSION = 1 VERSION = 1
async def async_step_user( async def async_step_user(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle the initial step.""" """Handle the initial step."""
errors: dict[str, str] = {} errors: dict[str, str] = {}
if user_input is not None: if user_input is not None:

7
homeassistant/components/vallox/config_flow.py
View file

@ -7,10 +7,9 @@ from typing import Any
from vallox_websocket_api import Vallox, ValloxApiException from vallox_websocket_api import Vallox, ValloxApiException
import voluptuous as vol import voluptuous as vol
from homeassistant import config_entries from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_HOST, CONF_NAME from homeassistant.const import CONF_HOST, CONF_NAME
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.data_entry_flow import FlowResult
from homeassistant.exceptions import HomeAssistantError from homeassistant.exceptions import HomeAssistantError
from homeassistant.util.network import is_ip_address from homeassistant.util.network import is_ip_address
@ -35,14 +34,14 @@ async def validate_host(hass: HomeAssistant, host: str) -> None:
await client.fetch_metric_data() await client.fetch_metric_data()
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN): class ValloxConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for the Vallox integration.""" """Handle a config flow for the Vallox integration."""
VERSION = 1 VERSION = 1
async def async_step_user( async def async_step_user(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle the initial step.""" """Handle the initial step."""
if user_input is None: if user_input is None:
return self.async_show_form( return self.async_show_form(

15
homeassistant/components/velbus/config_flow.py
View file

@ -7,16 +7,15 @@ import velbusaio.controller
from velbusaio.exceptions import VelbusConnectionFailed from velbusaio.exceptions import VelbusConnectionFailed
import voluptuous as vol import voluptuous as vol
from homeassistant import config_entries
from homeassistant.components import usb from homeassistant.components import usb
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_NAME, CONF_PORT from homeassistant.const import CONF_NAME, CONF_PORT
from homeassistant.data_entry_flow import FlowResult
from homeassistant.util import slugify from homeassistant.util import slugify
from .const import DOMAIN from .const import DOMAIN
class VelbusConfigFlow(config_entries.ConfigFlow, domain=DOMAIN): class VelbusConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow.""" """Handle a config flow."""
VERSION = 2 VERSION = 2
@ -27,7 +26,7 @@ class VelbusConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
self._device: str = "" self._device: str = ""
self._title: str = "" self._title: str = ""
def _create_device(self, name: str, prt: str) -> FlowResult: def _create_device(self, name: str, prt: str) -> ConfigFlowResult:
"""Create an entry async.""" """Create an entry async."""
return self.async_create_entry(title=name, data={CONF_PORT: prt}) return self.async_create_entry(title=name, data={CONF_PORT: prt})
@ -44,7 +43,7 @@ class VelbusConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user( async def async_step_user(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Step when user initializes a integration.""" """Step when user initializes a integration."""
self._errors = {} self._errors = {}
if user_input is not None: if user_input is not None:
@ -69,7 +68,9 @@ class VelbusConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
errors=self._errors, errors=self._errors,
) )
async def async_step_usb(self, discovery_info: usb.UsbServiceInfo) -> FlowResult: async def async_step_usb(
self, discovery_info: usb.UsbServiceInfo
) -> ConfigFlowResult:
"""Handle USB Discovery.""" """Handle USB Discovery."""
await self.async_set_unique_id( await self.async_set_unique_id(
f"{discovery_info.vid}:{discovery_info.pid}_{discovery_info.serial_number}_{discovery_info.manufacturer}_{discovery_info.description}" f"{discovery_info.vid}:{discovery_info.pid}_{discovery_info.serial_number}_{discovery_info.manufacturer}_{discovery_info.description}"
@ -89,7 +90,7 @@ class VelbusConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_discovery_confirm( async def async_step_discovery_confirm(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle Discovery confirmation.""" """Handle Discovery confirmation."""
if user_input is not None: if user_input is not None:
return self._create_device(self._title, self._device) return self._create_device(self._title, self._device)

7
homeassistant/components/velux/config_flow.py
View file

@ -7,7 +7,6 @@ import voluptuous as vol
from homeassistant import config_entries from homeassistant import config_entries
from homeassistant.const import CONF_HOST, CONF_PASSWORD from homeassistant.const import CONF_HOST, CONF_PASSWORD
from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN
from homeassistant.data_entry_flow import FlowResult
import homeassistant.helpers.config_validation as cv import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.issue_registry import IssueSeverity, async_create_issue from homeassistant.helpers.issue_registry import IssueSeverity, async_create_issue
@ -24,7 +23,9 @@ DATA_SCHEMA = vol.Schema(
class VeluxConfigFlow(config_entries.ConfigFlow, domain=DOMAIN): class VeluxConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
"""Handle a config flow for velux.""" """Handle a config flow for velux."""
async def async_step_import(self, config: dict[str, Any]) -> FlowResult: async def async_step_import(
self, config: dict[str, Any]
) -> config_entries.ConfigFlowResult:
"""Import a config entry.""" """Import a config entry."""
def create_repair(error: str | None = None) -> None: def create_repair(error: str | None = None) -> None:
@ -79,7 +80,7 @@ class VeluxConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user( async def async_step_user(
self, user_input: dict[str, str] | None = None self, user_input: dict[str, str] | None = None
) -> FlowResult: ) -> config_entries.ConfigFlowResult:
"""Handle the initial step.""" """Handle the initial step."""
errors: dict[str, str] = {} errors: dict[str, str] = {}

7
homeassistant/components/venstar/config_flow.py
View file

@ -4,7 +4,7 @@ from typing import Any
from venstarcolortouch import VenstarColorTouch from venstarcolortouch import VenstarColorTouch
import voluptuous as vol import voluptuous as vol
from homeassistant.config_entries import ConfigFlow from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import ( from homeassistant.const import (
CONF_HOST, CONF_HOST,
CONF_PASSWORD, CONF_PASSWORD,
@ -13,7 +13,6 @@ from homeassistant.const import (
CONF_USERNAME, CONF_USERNAME,
) )
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.data_entry_flow import FlowResult
from homeassistant.exceptions import HomeAssistantError from homeassistant.exceptions import HomeAssistantError
from homeassistant.helpers.typing import ConfigType from homeassistant.helpers.typing import ConfigType
@ -54,7 +53,7 @@ class VenstarConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_user( async def async_step_user(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Create config entry. Show the setup form to the user.""" """Create config entry. Show the setup form to the user."""
errors = {} errors = {}
@ -85,7 +84,7 @@ class VenstarConfigFlow(ConfigFlow, domain=DOMAIN):
errors=errors, errors=errors,
) )
async def async_step_import(self, import_data: ConfigType) -> FlowResult: async def async_step_import(self, import_data: ConfigType) -> ConfigFlowResult:
"""Import entry from configuration.yaml.""" """Import entry from configuration.yaml."""
self._async_abort_entries_match({CONF_HOST: import_data[CONF_HOST]}) self._async_abort_entries_match({CONF_HOST: import_data[CONF_HOST]})
return await self.async_step_user( return await self.async_step_user(

27
homeassistant/components/vera/config_flow.py
View file

@ -10,11 +10,16 @@ import pyvera as pv
from requests.exceptions import RequestException from requests.exceptions import RequestException
import voluptuous as vol import voluptuous as vol
from homeassistant import config_entries from homeassistant.config_entries import (
from homeassistant.config_entries import ConfigEntry SOURCE_IMPORT,
SOURCE_USER,
ConfigEntry,
ConfigFlow,
ConfigFlowResult,
OptionsFlow,
)
from homeassistant.const import CONF_EXCLUDE, CONF_LIGHTS, CONF_SOURCE from homeassistant.const import CONF_EXCLUDE, CONF_LIGHTS, CONF_SOURCE
from homeassistant.core import callback from homeassistant.core import callback
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers import entity_registry as er from homeassistant.helpers import entity_registry as er
from .const import CONF_CONTROLLER, CONF_LEGACY_UNIQUE_ID, DOMAIN from .const import CONF_CONTROLLER, CONF_LEGACY_UNIQUE_ID, DOMAIN
@ -68,7 +73,7 @@ def options_data(user_input: dict[str, str]) -> dict[str, list[int]]:
) )
class OptionsFlowHandler(config_entries.OptionsFlow): class OptionsFlowHandler(OptionsFlow):
"""Options for the component.""" """Options for the component."""
def __init__(self, config_entry: ConfigEntry) -> None: def __init__(self, config_entry: ConfigEntry) -> None:
@ -78,7 +83,7 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
async def async_step_init( async def async_step_init(
self, self,
user_input: dict[str, str] | None = None, user_input: dict[str, str] | None = None,
) -> FlowResult: ) -> ConfigFlowResult:
"""Manage the options.""" """Manage the options."""
if user_input is not None: if user_input is not None:
return self.async_create_entry( return self.async_create_entry(
@ -92,7 +97,7 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
) )
class VeraFlowHandler(config_entries.ConfigFlow, domain=DOMAIN): class VeraFlowHandler(ConfigFlow, domain=DOMAIN):
"""Vera config flow.""" """Vera config flow."""
@staticmethod @staticmethod
@ -103,14 +108,14 @@ class VeraFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user( async def async_step_user(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle user initiated flow.""" """Handle user initiated flow."""
if user_input is not None: if user_input is not None:
return await self.async_step_finish( return await self.async_step_finish(
{ {
**user_input, **user_input,
**options_data(user_input), **options_data(user_input),
**{CONF_SOURCE: config_entries.SOURCE_USER}, **{CONF_SOURCE: SOURCE_USER},
**{CONF_LEGACY_UNIQUE_ID: False}, **{CONF_LEGACY_UNIQUE_ID: False},
} }
) )
@ -122,7 +127,7 @@ class VeraFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
), ),
) )
async def async_step_import(self, config: dict[str, Any]) -> FlowResult: async def async_step_import(self, config: dict[str, Any]) -> ConfigFlowResult:
"""Handle a flow initialized by import.""" """Handle a flow initialized by import."""
# If there are entities with the legacy unique_id, then this imported config # If there are entities with the legacy unique_id, then this imported config
@ -142,12 +147,12 @@ class VeraFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
return await self.async_step_finish( return await self.async_step_finish(
{ {
**config, **config,
**{CONF_SOURCE: config_entries.SOURCE_IMPORT}, **{CONF_SOURCE: SOURCE_IMPORT},
**{CONF_LEGACY_UNIQUE_ID: use_legacy_unique_id}, **{CONF_LEGACY_UNIQUE_ID: use_legacy_unique_id},
} }
) )
async def async_step_finish(self, config: dict[str, Any]) -> FlowResult: async def async_step_finish(self, config: dict[str, Any]) -> ConfigFlowResult:
"""Validate and create config entry.""" """Validate and create config entry."""
base_url = config[CONF_CONTROLLER] = config[CONF_CONTROLLER].rstrip("/") base_url = config[CONF_CONTROLLER] = config[CONF_CONTROLLER].rstrip("/")
controller = pv.VeraController(base_url) controller = pv.VeraController(base_url)

24
homeassistant/components/verisure/config_flow.py
View file

@ -12,10 +12,14 @@ from verisure import (
) )
import voluptuous as vol import voluptuous as vol
from homeassistant.config_entries import ConfigEntry, ConfigFlow, OptionsFlow from homeassistant.config_entries import (
ConfigEntry,
ConfigFlow,
ConfigFlowResult,
OptionsFlow,
)
from homeassistant.const import CONF_CODE, CONF_EMAIL, CONF_PASSWORD from homeassistant.const import CONF_CODE, CONF_EMAIL, CONF_PASSWORD
from homeassistant.core import callback from homeassistant.core import callback
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers.storage import STORAGE_DIR from homeassistant.helpers.storage import STORAGE_DIR
from .const import ( from .const import (
@ -45,7 +49,7 @@ class VerisureConfigFlowHandler(ConfigFlow, domain=DOMAIN):
async def async_step_user( async def async_step_user(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle the initial step.""" """Handle the initial step."""
errors: dict[str, str] = {} errors: dict[str, str] = {}
@ -102,7 +106,7 @@ class VerisureConfigFlowHandler(ConfigFlow, domain=DOMAIN):
async def async_step_mfa( async def async_step_mfa(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle multifactor authentication step.""" """Handle multifactor authentication step."""
errors: dict[str, str] = {} errors: dict[str, str] = {}
@ -134,7 +138,7 @@ class VerisureConfigFlowHandler(ConfigFlow, domain=DOMAIN):
async def async_step_installation( async def async_step_installation(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Select Verisure installation to add.""" """Select Verisure installation to add."""
installations_data = await self.hass.async_add_executor_job( installations_data = await self.hass.async_add_executor_job(
self.verisure.get_installations self.verisure.get_installations
@ -170,7 +174,9 @@ class VerisureConfigFlowHandler(ConfigFlow, domain=DOMAIN):
}, },
) )
async def async_step_reauth(self, entry_data: Mapping[str, Any]) -> FlowResult: async def async_step_reauth(
self, entry_data: Mapping[str, Any]
) -> ConfigFlowResult:
"""Handle initiation of re-authentication with Verisure.""" """Handle initiation of re-authentication with Verisure."""
self.entry = cast( self.entry = cast(
ConfigEntry, ConfigEntry,
@ -180,7 +186,7 @@ class VerisureConfigFlowHandler(ConfigFlow, domain=DOMAIN):
async def async_step_reauth_confirm( async def async_step_reauth_confirm(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle re-authentication with Verisure.""" """Handle re-authentication with Verisure."""
errors: dict[str, str] = {} errors: dict[str, str] = {}
@ -250,7 +256,7 @@ class VerisureConfigFlowHandler(ConfigFlow, domain=DOMAIN):
async def async_step_reauth_mfa( async def async_step_reauth_mfa(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle multifactor authentication step during re-authentication.""" """Handle multifactor authentication step during re-authentication."""
errors: dict[str, str] = {} errors: dict[str, str] = {}
@ -303,7 +309,7 @@ class VerisureOptionsFlowHandler(OptionsFlow):
async def async_step_init( async def async_step_init(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Manage Verisure options.""" """Manage Verisure options."""
errors: dict[str, Any] = {} errors: dict[str, Any] = {}

9
homeassistant/components/version/config_flow.py
View file

@ -5,9 +5,8 @@ from typing import Any
import voluptuous as vol import voluptuous as vol
from homeassistant import config_entries from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_SOURCE from homeassistant.const import CONF_SOURCE
from homeassistant.data_entry_flow import FlowResult
from .const import ( from .const import (
ATTR_VERSION_SOURCE, ATTR_VERSION_SOURCE,
@ -33,7 +32,7 @@ from .const import (
) )
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN): class VersionConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Version.""" """Handle a config flow for Version."""
VERSION = 1 VERSION = 1
@ -45,7 +44,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user( async def async_step_user(
self, self,
user_input: dict[str, Any] | None = None, user_input: dict[str, Any] | None = None,
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle the initial user step.""" """Handle the initial user step."""
if user_input is None: if user_input is None:
self._entry_data = DEFAULT_CONFIGURATION.copy() self._entry_data = DEFAULT_CONFIGURATION.copy()
@ -78,7 +77,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_version_source( async def async_step_version_source(
self, self,
user_input: dict[str, Any] | None = None, user_input: dict[str, Any] | None = None,
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle the version_source step.""" """Handle the version_source step."""
if user_input is None: if user_input is None:
if self._entry_data[CONF_SOURCE] in ( if self._entry_data[CONF_SOURCE] in (

4
homeassistant/components/vesync/config_flow.py
View file

@ -4,14 +4,14 @@ from collections import OrderedDict
from pyvesync import VeSync from pyvesync import VeSync
import voluptuous as vol import voluptuous as vol
from homeassistant import config_entries from homeassistant.config_entries import ConfigFlow
from homeassistant.const import CONF_PASSWORD, CONF_USERNAME from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
from homeassistant.core import callback from homeassistant.core import callback
from .const import DOMAIN from .const import DOMAIN
class VeSyncFlowHandler(config_entries.ConfigFlow, domain=DOMAIN): class VeSyncFlowHandler(ConfigFlow, domain=DOMAIN):
"""Handle a config flow.""" """Handle a config flow."""
VERSION = 1 VERSION = 1

19
homeassistant/components/vicare/config_flow.py
View file

@ -11,10 +11,9 @@ from PyViCare.PyViCareUtils import (
) )
import voluptuous as vol import voluptuous as vol
from homeassistant import config_entries
from homeassistant.components import dhcp from homeassistant.components import dhcp
from homeassistant.config_entries import ConfigEntry, ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_CLIENT_ID, CONF_PASSWORD, CONF_USERNAME from homeassistant.const import CONF_CLIENT_ID, CONF_PASSWORD, CONF_USERNAME
from homeassistant.data_entry_flow import FlowResult
import homeassistant.helpers.config_validation as cv import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.device_registry import format_mac from homeassistant.helpers.device_registry import format_mac
@ -46,15 +45,15 @@ USER_SCHEMA = REAUTH_SCHEMA.extend(
) )
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN): class ViCareConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for ViCare.""" """Handle a config flow for ViCare."""
VERSION = 1 VERSION = 1
entry: config_entries.ConfigEntry | None entry: ConfigEntry | None
async def async_step_user( async def async_step_user(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Invoke when a user initiates a flow via the user interface.""" """Invoke when a user initiates a flow via the user interface."""
if self._async_current_entries(): if self._async_current_entries():
return self.async_abort(reason="single_instance_allowed") return self.async_abort(reason="single_instance_allowed")
@ -77,14 +76,16 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
errors=errors, errors=errors,
) )
async def async_step_reauth(self, entry_data: Mapping[str, Any]) -> FlowResult: async def async_step_reauth(
self, entry_data: Mapping[str, Any]
) -> ConfigFlowResult:
"""Handle re-authentication with ViCare.""" """Handle re-authentication with ViCare."""
self.entry = self.hass.config_entries.async_get_entry(self.context["entry_id"]) self.entry = self.hass.config_entries.async_get_entry(self.context["entry_id"])
return await self.async_step_reauth_confirm() return await self.async_step_reauth_confirm()
async def async_step_reauth_confirm( async def async_step_reauth_confirm(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Confirm re-authentication with ViCare.""" """Confirm re-authentication with ViCare."""
errors: dict[str, str] = {} errors: dict[str, str] = {}
assert self.entry is not None assert self.entry is not None
@ -115,7 +116,9 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
errors=errors, errors=errors,
) )
async def async_step_dhcp(self, discovery_info: dhcp.DhcpServiceInfo) -> FlowResult: async def async_step_dhcp(
self, discovery_info: dhcp.DhcpServiceInfo
) -> ConfigFlowResult:
"""Invoke when a Viessmann MAC address is discovered on the network.""" """Invoke when a Viessmann MAC address is discovered on the network."""
formatted_mac = format_mac(discovery_info.macaddress) formatted_mac = format_mac(discovery_info.macaddress)
_LOGGER.debug("Found device with mac %s", formatted_mac) _LOGGER.debug("Found device with mac %s", formatted_mac)

14
homeassistant/components/vilfo/config_flow.py
View file

@ -8,8 +8,10 @@ from vilfo.exceptions import (
) )
import voluptuous as vol import voluptuous as vol
from homeassistant import config_entries, core, exceptions from homeassistant.config_entries import ConfigFlow
from homeassistant.const import CONF_ACCESS_TOKEN, CONF_HOST, CONF_ID, CONF_MAC from homeassistant.const import CONF_ACCESS_TOKEN, CONF_HOST, CONF_ID, CONF_MAC
from homeassistant.core import HomeAssistant
from homeassistant.exceptions import HomeAssistantError
from homeassistant.util.network import is_host_valid from homeassistant.util.network import is_host_valid
from .const import DOMAIN, ROUTER_DEFAULT_HOST from .const import DOMAIN, ROUTER_DEFAULT_HOST
@ -62,7 +64,7 @@ def _try_connect_and_fetch_basic_info(host, token):
return result return result
async def validate_input(hass: core.HomeAssistant, data): async def validate_input(hass: HomeAssistant, data):
"""Validate the user input allows us to connect. """Validate the user input allows us to connect.
Data has the keys from DATA_SCHEMA with values provided by the user. Data has the keys from DATA_SCHEMA with values provided by the user.
@ -91,7 +93,7 @@ async def validate_input(hass: core.HomeAssistant, data):
return config return config
class DomainConfigFlow(config_entries.ConfigFlow, domain=DOMAIN): class DomainConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Vilfo Router.""" """Handle a config flow for Vilfo Router."""
VERSION = 1 VERSION = 1
@ -122,13 +124,13 @@ class DomainConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
) )
class CannotConnect(exceptions.HomeAssistantError): class CannotConnect(HomeAssistantError):
"""Error to indicate we cannot connect.""" """Error to indicate we cannot connect."""
class InvalidAuth(exceptions.HomeAssistantError): class InvalidAuth(HomeAssistantError):
"""Error to indicate there is invalid auth.""" """Error to indicate there is invalid auth."""
class InvalidHost(exceptions.HomeAssistantError): class InvalidHost(HomeAssistantError):
"""Error to indicate that hostname/IP address is invalid.""" """Error to indicate that hostname/IP address is invalid."""

29
homeassistant/components/vizio/config_flow.py
View file

@ -10,7 +10,6 @@ from pyvizio import VizioAsync, async_guess_device_type
from pyvizio.const import APP_HOME from pyvizio.const import APP_HOME
import voluptuous as vol import voluptuous as vol
from homeassistant import config_entries
from homeassistant.components import zeroconf from homeassistant.components import zeroconf
from homeassistant.components.media_player import MediaPlayerDeviceClass from homeassistant.components.media_player import MediaPlayerDeviceClass
from homeassistant.config_entries import ( from homeassistant.config_entries import (
@ -18,6 +17,9 @@ from homeassistant.config_entries import (
SOURCE_IMPORT, SOURCE_IMPORT,
SOURCE_ZEROCONF, SOURCE_ZEROCONF,
ConfigEntry, ConfigEntry,
ConfigFlow,
ConfigFlowResult,
OptionsFlow,
) )
from homeassistant.const import ( from homeassistant.const import (
CONF_ACCESS_TOKEN, CONF_ACCESS_TOKEN,
@ -29,7 +31,6 @@ from homeassistant.const import (
CONF_PIN, CONF_PIN,
) )
from homeassistant.core import callback from homeassistant.core import callback
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers import config_validation as cv from homeassistant.helpers import config_validation as cv
from homeassistant.helpers.aiohttp_client import async_get_clientsession from homeassistant.helpers.aiohttp_client import async_get_clientsession
from homeassistant.util.network import is_ip_address from homeassistant.util.network import is_ip_address
@ -103,7 +104,7 @@ def _host_is_same(host1: str, host2: str) -> bool:
return host1 == host2 return host1 == host2
class VizioOptionsConfigFlow(config_entries.OptionsFlow): class VizioOptionsConfigFlow(OptionsFlow):
"""Handle Vizio options.""" """Handle Vizio options."""
def __init__(self, config_entry: ConfigEntry) -> None: def __init__(self, config_entry: ConfigEntry) -> None:
@ -112,7 +113,7 @@ class VizioOptionsConfigFlow(config_entries.OptionsFlow):
async def async_step_init( async def async_step_init(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Manage the vizio options.""" """Manage the vizio options."""
if user_input is not None: if user_input is not None:
if user_input.get(CONF_APPS_TO_INCLUDE_OR_EXCLUDE): if user_input.get(CONF_APPS_TO_INCLUDE_OR_EXCLUDE):
@ -173,7 +174,7 @@ class VizioOptionsConfigFlow(config_entries.OptionsFlow):
return self.async_show_form(step_id="init", data_schema=options) return self.async_show_form(step_id="init", data_schema=options)
class VizioConfigFlow(config_entries.ConfigFlow, domain=DOMAIN): class VizioConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a Vizio config flow.""" """Handle a Vizio config flow."""
VERSION = 1 VERSION = 1
@ -193,7 +194,7 @@ class VizioConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
self._data: dict[str, Any] | None = None self._data: dict[str, Any] | None = None
self._apps: dict[str, list] = {} self._apps: dict[str, list] = {}
async def _create_entry(self, input_dict: dict[str, Any]) -> FlowResult: async def _create_entry(self, input_dict: dict[str, Any]) -> ConfigFlowResult:
"""Create vizio config entry.""" """Create vizio config entry."""
# Remove extra keys that will not be used by entry setup # Remove extra keys that will not be used by entry setup
input_dict.pop(CONF_APPS_TO_INCLUDE_OR_EXCLUDE, None) input_dict.pop(CONF_APPS_TO_INCLUDE_OR_EXCLUDE, None)
@ -206,7 +207,7 @@ class VizioConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user( async def async_step_user(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle a flow initialized by the user.""" """Handle a flow initialized by the user."""
errors: dict[str, str] = {} errors: dict[str, str] = {}
@ -283,7 +284,9 @@ class VizioConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
return self.async_show_form(step_id="user", data_schema=schema, errors=errors) return self.async_show_form(step_id="user", data_schema=schema, errors=errors)
async def async_step_import(self, import_config: dict[str, Any]) -> FlowResult: async def async_step_import(
self, import_config: dict[str, Any]
) -> ConfigFlowResult:
"""Import a config entry from configuration.yaml.""" """Import a config entry from configuration.yaml."""
# Check if new config entry matches any existing config entries # Check if new config entry matches any existing config entries
for entry in self._async_current_entries(): for entry in self._async_current_entries():
@ -347,7 +350,7 @@ class VizioConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_zeroconf( async def async_step_zeroconf(
self, discovery_info: zeroconf.ZeroconfServiceInfo self, discovery_info: zeroconf.ZeroconfServiceInfo
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle zeroconf discovery.""" """Handle zeroconf discovery."""
host = discovery_info.host host = discovery_info.host
# If host already has port, no need to add it again # If host already has port, no need to add it again
@ -387,7 +390,7 @@ class VizioConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_pair_tv( async def async_step_pair_tv(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Start pairing process for TV. """Start pairing process for TV.
Ask user for PIN to complete pairing process. Ask user for PIN to complete pairing process.
@ -452,7 +455,7 @@ class VizioConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
errors=errors, errors=errors,
) )
async def _pairing_complete(self, step_id: str) -> FlowResult: async def _pairing_complete(self, step_id: str) -> ConfigFlowResult:
"""Handle config flow completion.""" """Handle config flow completion."""
assert self._data assert self._data
if not self._must_show_form: if not self._must_show_form:
@ -466,7 +469,7 @@ class VizioConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_pairing_complete( async def async_step_pairing_complete(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Complete non-import sourced config flow. """Complete non-import sourced config flow.
Display final message to user confirming pairing. Display final message to user confirming pairing.
@ -475,7 +478,7 @@ class VizioConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_pairing_complete_import( async def async_step_pairing_complete_import(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Complete import sourced config flow. """Complete import sourced config flow.
Display final message to user confirming pairing and displaying Display final message to user confirming pairing and displaying

28
homeassistant/components/vlc_telnet/config_flow.py
View file

@ -9,11 +9,11 @@ from aiovlc.client import Client
from aiovlc.exceptions import AuthError, ConnectError from aiovlc.exceptions import AuthError, ConnectError
import voluptuous as vol import voluptuous as vol
from homeassistant import core, exceptions
from homeassistant.components.hassio import HassioServiceInfo from homeassistant.components.hassio import HassioServiceInfo
from homeassistant.config_entries import ConfigEntry, ConfigFlow from homeassistant.config_entries import ConfigEntry, ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_HOST, CONF_NAME, CONF_PASSWORD, CONF_PORT from homeassistant.const import CONF_HOST, CONF_NAME, CONF_PASSWORD, CONF_PORT
from homeassistant.data_entry_flow import FlowResult from homeassistant.core import HomeAssistant
from homeassistant.exceptions import HomeAssistantError
from .const import DEFAULT_PORT, DOMAIN from .const import DEFAULT_PORT, DOMAIN
@ -46,9 +46,7 @@ async def vlc_connect(vlc: Client) -> None:
await vlc.disconnect() await vlc.disconnect()
async def validate_input( async def validate_input(hass: HomeAssistant, data: dict[str, Any]) -> dict[str, str]:
hass: core.HomeAssistant, data: dict[str, Any]
) -> dict[str, str]:
"""Validate the user input allows us to connect.""" """Validate the user input allows us to connect."""
vlc = Client( vlc = Client(
password=data[CONF_PASSWORD], password=data[CONF_PASSWORD],
@ -76,7 +74,7 @@ class VLCTelnetConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_user( async def async_step_user(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle the initial step.""" """Handle the initial step."""
if user_input is None: if user_input is None:
return self.async_show_form( return self.async_show_form(
@ -105,7 +103,9 @@ class VLCTelnetConfigFlow(ConfigFlow, domain=DOMAIN):
step_id="user", data_schema=user_form_schema(user_input), errors=errors step_id="user", data_schema=user_form_schema(user_input), errors=errors
) )
async def async_step_reauth(self, entry_data: Mapping[str, Any]) -> FlowResult: async def async_step_reauth(
self, entry_data: Mapping[str, Any]
) -> ConfigFlowResult:
"""Handle reauth flow.""" """Handle reauth flow."""
self.entry = self.hass.config_entries.async_get_entry(self.context["entry_id"]) self.entry = self.hass.config_entries.async_get_entry(self.context["entry_id"])
assert self.entry assert self.entry
@ -114,7 +114,7 @@ class VLCTelnetConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_reauth_confirm( async def async_step_reauth_confirm(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle reauth confirm.""" """Handle reauth confirm."""
assert self.entry assert self.entry
errors = {} errors = {}
@ -149,7 +149,9 @@ class VLCTelnetConfigFlow(ConfigFlow, domain=DOMAIN):
errors=errors, errors=errors,
) )
async def async_step_hassio(self, discovery_info: HassioServiceInfo) -> FlowResult: async def async_step_hassio(
self, discovery_info: HassioServiceInfo
) -> ConfigFlowResult:
"""Handle the discovery step via hassio.""" """Handle the discovery step via hassio."""
await self.async_set_unique_id("hassio") await self.async_set_unique_id("hassio")
self._abort_if_unique_id_configured(discovery_info.config) self._abort_if_unique_id_configured(discovery_info.config)
@ -160,7 +162,7 @@ class VLCTelnetConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_hassio_confirm( async def async_step_hassio_confirm(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Confirm Supervisor discovery.""" """Confirm Supervisor discovery."""
assert self.hassio_discovery assert self.hassio_discovery
if user_input is None: if user_input is None:
@ -184,9 +186,9 @@ class VLCTelnetConfigFlow(ConfigFlow, domain=DOMAIN):
return self.async_create_entry(title=info["title"], data=self.hassio_discovery) return self.async_create_entry(title=info["title"], data=self.hassio_discovery)
class CannotConnect(exceptions.HomeAssistantError): class CannotConnect(HomeAssistantError):
"""Error to indicate we cannot connect.""" """Error to indicate we cannot connect."""
class InvalidAuth(exceptions.HomeAssistantError): class InvalidAuth(HomeAssistantError):
"""Error to indicate there is invalid auth.""" """Error to indicate there is invalid auth."""

12
homeassistant/components/vodafone_station/config_flow.py
View file

@ -14,12 +14,12 @@ from homeassistant.components.device_tracker import (
from homeassistant.config_entries import ( from homeassistant.config_entries import (
ConfigEntry, ConfigEntry,
ConfigFlow, ConfigFlow,
ConfigFlowResult,
OptionsFlow, OptionsFlow,
OptionsFlowWithConfigEntry, OptionsFlowWithConfigEntry,
) )
from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
from homeassistant.core import HomeAssistant, callback from homeassistant.core import HomeAssistant, callback
from homeassistant.data_entry_flow import FlowResult
from .const import _LOGGER, DEFAULT_HOST, DEFAULT_USERNAME, DOMAIN from .const import _LOGGER, DEFAULT_HOST, DEFAULT_USERNAME, DOMAIN
@ -69,7 +69,7 @@ class VodafoneStationConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_user( async def async_step_user(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle the initial step.""" """Handle the initial step."""
if user_input is None: if user_input is None:
return self.async_show_form( return self.async_show_form(
@ -101,7 +101,9 @@ class VodafoneStationConfigFlow(ConfigFlow, domain=DOMAIN):
step_id="user", data_schema=user_form_schema(user_input), errors=errors step_id="user", data_schema=user_form_schema(user_input), errors=errors
) )
async def async_step_reauth(self, entry_data: Mapping[str, Any]) -> FlowResult: async def async_step_reauth(
self, entry_data: Mapping[str, Any]
) -> ConfigFlowResult:
"""Handle reauth flow.""" """Handle reauth flow."""
self.entry = self.hass.config_entries.async_get_entry(self.context["entry_id"]) self.entry = self.hass.config_entries.async_get_entry(self.context["entry_id"])
assert self.entry assert self.entry
@ -110,7 +112,7 @@ class VodafoneStationConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_reauth_confirm( async def async_step_reauth_confirm(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle reauth confirm.""" """Handle reauth confirm."""
assert self.entry assert self.entry
errors = {} errors = {}
@ -153,7 +155,7 @@ class VodafoneStationOptionsFlowHandler(OptionsFlowWithConfigEntry):
async def async_step_init( async def async_step_init(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle options flow.""" """Handle options flow."""
if user_input is not None: if user_input is not None:

22
homeassistant/components/voip/config_flow.py
View file

@ -6,22 +6,26 @@ from typing import Any
from voip_utils import SIP_PORT from voip_utils import SIP_PORT
import voluptuous as vol import voluptuous as vol
from homeassistant import config_entries from homeassistant.config_entries import (
ConfigEntry,
ConfigFlow,
ConfigFlowResult,
OptionsFlow,
)
from homeassistant.core import callback from homeassistant.core import callback
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers import config_validation as cv from homeassistant.helpers import config_validation as cv
from .const import CONF_SIP_PORT, DOMAIN from .const import CONF_SIP_PORT, DOMAIN
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN): class VoIPConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for VoIP integration.""" """Handle a config flow for VoIP integration."""
VERSION = 1 VERSION = 1
async def async_step_user( async def async_step_user(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle the initial step.""" """Handle the initial step."""
if self._async_current_entries(): if self._async_current_entries():
return self.async_abort(reason="single_instance_allowed") return self.async_abort(reason="single_instance_allowed")
@ -39,22 +43,22 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
@staticmethod @staticmethod
@callback @callback
def async_get_options_flow( def async_get_options_flow(
config_entry: config_entries.ConfigEntry, config_entry: ConfigEntry,
) -> config_entries.OptionsFlow: ) -> OptionsFlow:
"""Create the options flow.""" """Create the options flow."""
return VoipOptionsFlowHandler(config_entry) return VoipOptionsFlowHandler(config_entry)
class VoipOptionsFlowHandler(config_entries.OptionsFlow): class VoipOptionsFlowHandler(OptionsFlow):
"""Handle VoIP options.""" """Handle VoIP options."""
def __init__(self, config_entry: config_entries.ConfigEntry) -> None: def __init__(self, config_entry: ConfigEntry) -> None:
"""Initialize options flow.""" """Initialize options flow."""
self.config_entry = config_entry self.config_entry = config_entry
async def async_step_init( async def async_step_init(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Manage the options.""" """Manage the options."""
if user_input is not None: if user_input is not None:
return self.async_create_entry(title="", data=user_input) return self.async_create_entry(title="", data=user_input)

10
homeassistant/components/volumio/config_flow.py
View file

@ -6,11 +6,11 @@ import logging
from pyvolumio import CannotConnectError, Volumio from pyvolumio import CannotConnectError, Volumio
import voluptuous as vol import voluptuous as vol
from homeassistant import config_entries, exceptions
from homeassistant.components import zeroconf from homeassistant.components import zeroconf
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_HOST, CONF_ID, CONF_NAME, CONF_PORT from homeassistant.const import CONF_HOST, CONF_ID, CONF_NAME, CONF_PORT
from homeassistant.core import callback from homeassistant.core import callback
from homeassistant.data_entry_flow import FlowResult from homeassistant.exceptions import HomeAssistantError
from homeassistant.helpers.aiohttp_client import async_get_clientsession from homeassistant.helpers.aiohttp_client import async_get_clientsession
from .const import DOMAIN from .const import DOMAIN
@ -33,7 +33,7 @@ async def validate_input(hass, host, port):
raise CannotConnect from error raise CannotConnect from error
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN): class VolumioConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Volumio.""" """Handle a config flow for Volumio."""
VERSION = 1 VERSION = 1
@ -96,7 +96,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_zeroconf( async def async_step_zeroconf(
self, discovery_info: zeroconf.ZeroconfServiceInfo self, discovery_info: zeroconf.ZeroconfServiceInfo
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle zeroconf discovery.""" """Handle zeroconf discovery."""
self._host = discovery_info.host self._host = discovery_info.host
self._port = discovery_info.port self._port = discovery_info.port
@ -121,5 +121,5 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
) )
class CannotConnect(exceptions.HomeAssistantError): class CannotConnect(HomeAssistantError):
"""Error to indicate we cannot connect.""" """Error to indicate we cannot connect."""

13
homeassistant/components/volvooncall/config_flow.py
View file

@ -8,14 +8,13 @@ from typing import Any
import voluptuous as vol import voluptuous as vol
from volvooncall import Connection from volvooncall import Connection
from homeassistant import config_entries from homeassistant.config_entries import ConfigEntry, ConfigFlow, ConfigFlowResult
from homeassistant.const import ( from homeassistant.const import (
CONF_PASSWORD, CONF_PASSWORD,
CONF_REGION, CONF_REGION,
CONF_UNIT_SYSTEM, CONF_UNIT_SYSTEM,
CONF_USERNAME, CONF_USERNAME,
) )
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers.aiohttp_client import async_get_clientsession from homeassistant.helpers.aiohttp_client import async_get_clientsession
from . import VolvoData from . import VolvoData
@ -31,15 +30,15 @@ from .errors import InvalidAuth
_LOGGER = logging.getLogger(__name__) _LOGGER = logging.getLogger(__name__)
class VolvoOnCallConfigFlow(config_entries.ConfigFlow, domain=DOMAIN): class VolvoOnCallConfigFlow(ConfigFlow, domain=DOMAIN):
"""VolvoOnCall config flow.""" """VolvoOnCall config flow."""
VERSION = 1 VERSION = 1
_reauth_entry: config_entries.ConfigEntry | None = None _reauth_entry: ConfigEntry | None = None
async def async_step_user( async def async_step_user(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle user step.""" """Handle user step."""
errors = {} errors = {}
defaults = { defaults = {
@ -106,7 +105,9 @@ class VolvoOnCallConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
step_id="user", data_schema=user_schema, errors=errors step_id="user", data_schema=user_schema, errors=errors
) )
async def async_step_reauth(self, user_input: Mapping[str, Any]) -> FlowResult: async def async_step_reauth(
self, user_input: Mapping[str, Any]
) -> ConfigFlowResult:
"""Perform reauth upon an API authentication error.""" """Perform reauth upon an API authentication error."""
self._reauth_entry = self.hass.config_entries.async_get_entry( self._reauth_entry = self.hass.config_entries.async_get_entry(
self.context["entry_id"] self.context["entry_id"]

9
homeassistant/components/vulcan/config_flow.py
View file

@ -16,9 +16,8 @@ from vulcan import (
Vulcan, Vulcan,
) )
from homeassistant import config_entries from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_PIN, CONF_REGION, CONF_TOKEN from homeassistant.const import CONF_PIN, CONF_REGION, CONF_TOKEN
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers.aiohttp_client import async_get_clientsession from homeassistant.helpers.aiohttp_client import async_get_clientsession
from . import DOMAIN from . import DOMAIN
@ -33,7 +32,7 @@ LOGIN_SCHEMA = {
} }
class VulcanFlowHandler(config_entries.ConfigFlow, domain=DOMAIN): class VulcanFlowHandler(ConfigFlow, domain=DOMAIN):
"""Handle a Uonet+ Vulcan config flow.""" """Handle a Uonet+ Vulcan config flow."""
VERSION = 1 VERSION = 1
@ -241,7 +240,9 @@ class VulcanFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
errors=errors, errors=errors,
) )
async def async_step_reauth(self, entry_data: Mapping[str, Any]) -> FlowResult: async def async_step_reauth(
self, entry_data: Mapping[str, Any]
) -> ConfigFlowResult:
"""Perform reauth upon an API authentication error.""" """Perform reauth upon an API authentication error."""
return await self.async_step_reauth_confirm() return await self.async_step_reauth_confirm()

18
homeassistant/components/wallbox/config_flow.py
View file

@ -7,9 +7,9 @@ from typing import Any
import voluptuous as vol import voluptuous as vol
from wallbox import Wallbox from wallbox import Wallbox
from homeassistant import config_entries, core from homeassistant.config_entries import ConfigEntry, ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_PASSWORD, CONF_USERNAME from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
from homeassistant.data_entry_flow import FlowResult from homeassistant.core import HomeAssistant
from .const import CONF_STATION, DOMAIN from .const import CONF_STATION, DOMAIN
from .coordinator import InvalidAuth, WallboxCoordinator from .coordinator import InvalidAuth, WallboxCoordinator
@ -25,9 +25,7 @@ STEP_USER_DATA_SCHEMA = vol.Schema(
) )
async def validate_input( async def validate_input(hass: HomeAssistant, data: dict[str, Any]) -> dict[str, str]:
hass: core.HomeAssistant, data: dict[str, Any]
) -> dict[str, str]:
"""Validate the user input allows to connect. """Validate the user input allows to connect.
Data has the keys from STEP_USER_DATA_SCHEMA with values provided by the user. Data has the keys from STEP_USER_DATA_SCHEMA with values provided by the user.
@ -41,14 +39,16 @@ async def validate_input(
return {"title": "Wallbox Portal"} return {"title": "Wallbox Portal"}
class ConfigFlow(config_entries.ConfigFlow, domain=COMPONENT_DOMAIN): class WallboxConfigFlow(ConfigFlow, domain=COMPONENT_DOMAIN):
"""Handle a config flow for Wallbox.""" """Handle a config flow for Wallbox."""
def __init__(self) -> None: def __init__(self) -> None:
"""Start the Wallbox config flow.""" """Start the Wallbox config flow."""
self._reauth_entry: config_entries.ConfigEntry | None = None self._reauth_entry: ConfigEntry | None = None
async def async_step_reauth(self, entry_data: Mapping[str, Any]) -> FlowResult: async def async_step_reauth(
self, entry_data: Mapping[str, Any]
) -> ConfigFlowResult:
"""Perform reauth upon an API authentication error.""" """Perform reauth upon an API authentication error."""
self._reauth_entry = self.hass.config_entries.async_get_entry( self._reauth_entry = self.hass.config_entries.async_get_entry(
self.context["entry_id"] self.context["entry_id"]
@ -58,7 +58,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=COMPONENT_DOMAIN):
async def async_step_user( async def async_step_user(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle the initial step.""" """Handle the initial step."""
if user_input is None: if user_input is None:
return self.async_show_form( return self.async_show_form(

14
homeassistant/components/waqi/config_flow.py
View file

@ -12,7 +12,7 @@ from aiowaqi import (
) )
import voluptuous as vol import voluptuous as vol
from homeassistant.config_entries import ConfigFlow from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import ( from homeassistant.const import (
CONF_API_KEY, CONF_API_KEY,
CONF_LATITUDE, CONF_LATITUDE,
@ -22,7 +22,7 @@ from homeassistant.const import (
CONF_NAME, CONF_NAME,
) )
from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN
from homeassistant.data_entry_flow import AbortFlow, FlowResult from homeassistant.data_entry_flow import AbortFlow
from homeassistant.helpers.aiohttp_client import async_get_clientsession from homeassistant.helpers.aiohttp_client import async_get_clientsession
from homeassistant.helpers.issue_registry import IssueSeverity, async_create_issue from homeassistant.helpers.issue_registry import IssueSeverity, async_create_issue
from homeassistant.helpers.selector import ( from homeassistant.helpers.selector import (
@ -66,7 +66,7 @@ class WAQIConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_user( async def async_step_user(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle the initial step.""" """Handle the initial step."""
errors: dict[str, str] = {} errors: dict[str, str] = {}
if user_input is not None: if user_input is not None:
@ -107,7 +107,7 @@ class WAQIConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_map( async def async_step_map(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Add measuring station via map.""" """Add measuring station via map."""
errors: dict[str, str] = {} errors: dict[str, str] = {}
if user_input is not None: if user_input is not None:
@ -149,7 +149,7 @@ class WAQIConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_station_number( async def async_step_station_number(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Add measuring station via station number.""" """Add measuring station via station number."""
errors: dict[str, str] = {} errors: dict[str, str] = {}
if user_input is not None: if user_input is not None:
@ -182,7 +182,7 @@ class WAQIConfigFlow(ConfigFlow, domain=DOMAIN):
async def _async_create_entry( async def _async_create_entry(
self, measuring_station: WAQIAirQuality self, measuring_station: WAQIAirQuality
) -> FlowResult: ) -> ConfigFlowResult:
await self.async_set_unique_id(str(measuring_station.station_id)) await self.async_set_unique_id(str(measuring_station.station_id))
self._abort_if_unique_id_configured() self._abort_if_unique_id_configured()
return self.async_create_entry( return self.async_create_entry(
@ -193,7 +193,7 @@ class WAQIConfigFlow(ConfigFlow, domain=DOMAIN):
}, },
) )
async def async_step_import(self, import_config: ConfigType) -> FlowResult: async def async_step_import(self, import_config: ConfigType) -> ConfigFlowResult:
"""Handle importing from yaml.""" """Handle importing from yaml."""
await self.async_set_unique_id(str(import_config[CONF_STATION_NUMBER])) await self.async_set_unique_id(str(import_config[CONF_STATION_NUMBER]))
try: try:

29
homeassistant/components/watttime/config_flow.py
View file

@ -8,8 +8,12 @@ from aiowatttime import Client
from aiowatttime.errors import CoordinatesNotFoundError, InvalidCredentialsError from aiowatttime.errors import CoordinatesNotFoundError, InvalidCredentialsError
import voluptuous as vol import voluptuous as vol
from homeassistant import config_entries from homeassistant.config_entries import (
from homeassistant.config_entries import ConfigEntry, OptionsFlow ConfigEntry,
ConfigFlow,
ConfigFlowResult,
OptionsFlow,
)
from homeassistant.const import ( from homeassistant.const import (
CONF_LATITUDE, CONF_LATITUDE,
CONF_LONGITUDE, CONF_LONGITUDE,
@ -18,7 +22,6 @@ from homeassistant.const import (
CONF_USERNAME, CONF_USERNAME,
) )
from homeassistant.core import callback from homeassistant.core import callback
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers import aiohttp_client, config_validation as cv from homeassistant.helpers import aiohttp_client, config_validation as cv
from .const import ( from .const import (
@ -68,7 +71,7 @@ def get_unique_id(data: dict[str, Any]) -> str:
return f"{data[CONF_LATITUDE]}, {data[CONF_LONGITUDE]}" return f"{data[CONF_LATITUDE]}, {data[CONF_LONGITUDE]}"
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN): class WattTimeConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for WattTime.""" """Handle a config flow for WattTime."""
VERSION = 1 VERSION = 1
@ -80,7 +83,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def _async_validate_credentials( async def _async_validate_credentials(
self, username: str, password: str, error_step_id: str, error_schema: vol.Schema self, username: str, password: str, error_step_id: str, error_schema: vol.Schema
) -> FlowResult: ) -> ConfigFlowResult:
"""Validate input credentials and proceed accordingly.""" """Validate input credentials and proceed accordingly."""
session = aiohttp_client.async_get_clientsession(self.hass) session = aiohttp_client.async_get_clientsession(self.hass)
@ -128,7 +131,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_coordinates( async def async_step_coordinates(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle the coordinates step.""" """Handle the coordinates step."""
if not user_input: if not user_input:
return self.async_show_form( return self.async_show_form(
@ -174,7 +177,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_location( async def async_step_location(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle the "pick a location" step.""" """Handle the "pick a location" step."""
if not user_input: if not user_input:
return self.async_show_form( return self.async_show_form(
@ -190,14 +193,16 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
) )
return await self.async_step_coordinates() return await self.async_step_coordinates()
async def async_step_reauth(self, entry_data: Mapping[str, Any]) -> FlowResult: async def async_step_reauth(
self, entry_data: Mapping[str, Any]
) -> ConfigFlowResult:
"""Handle configuration by re-auth.""" """Handle configuration by re-auth."""
self._data = {**entry_data} self._data = {**entry_data}
return await self.async_step_reauth_confirm() return await self.async_step_reauth_confirm()
async def async_step_reauth_confirm( async def async_step_reauth_confirm(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle re-auth completion.""" """Handle re-auth completion."""
if not user_input: if not user_input:
return self.async_show_form( return self.async_show_form(
@ -217,7 +222,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user( async def async_step_user(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle the initial step.""" """Handle the initial step."""
if not user_input: if not user_input:
return self.async_show_form( return self.async_show_form(
@ -232,7 +237,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
) )
class WattTimeOptionsFlowHandler(config_entries.OptionsFlow): class WattTimeOptionsFlowHandler(OptionsFlow):
"""Handle a WattTime options flow.""" """Handle a WattTime options flow."""
def __init__(self, entry: ConfigEntry) -> None: def __init__(self, entry: ConfigEntry) -> None:
@ -241,7 +246,7 @@ class WattTimeOptionsFlowHandler(config_entries.OptionsFlow):
async def async_step_init( async def async_step_init(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Manage the options.""" """Manage the options."""
if user_input is not None: if user_input is not None:
return self.async_create_entry(data=user_input) return self.async_create_entry(data=user_input)

20
homeassistant/components/waze_travel_time/config_flow.py
View file

@ -3,10 +3,14 @@ from __future__ import annotations
import voluptuous as vol import voluptuous as vol
from homeassistant import config_entries from homeassistant.config_entries import (
ConfigEntry,
ConfigFlow,
ConfigFlowResult,
OptionsFlow,
)
from homeassistant.const import CONF_NAME, CONF_REGION from homeassistant.const import CONF_NAME, CONF_REGION
from homeassistant.core import HomeAssistant, callback from homeassistant.core import HomeAssistant, callback
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers.selector import ( from homeassistant.helpers.selector import (
BooleanSelector, BooleanSelector,
SelectSelector, SelectSelector,
@ -86,14 +90,14 @@ def default_options(hass: HomeAssistant) -> dict[str, str | bool]:
return defaults return defaults
class WazeOptionsFlow(config_entries.OptionsFlow): class WazeOptionsFlow(OptionsFlow):
"""Handle an options flow for Waze Travel Time.""" """Handle an options flow for Waze Travel Time."""
def __init__(self, config_entry: config_entries.ConfigEntry) -> None: def __init__(self, config_entry: ConfigEntry) -> None:
"""Initialize waze options flow.""" """Initialize waze options flow."""
self.config_entry = config_entry self.config_entry = config_entry
async def async_step_init(self, user_input=None) -> FlowResult: async def async_step_init(self, user_input=None) -> ConfigFlowResult:
"""Handle the initial step.""" """Handle the initial step."""
if user_input is not None: if user_input is not None:
return self.async_create_entry( return self.async_create_entry(
@ -109,7 +113,7 @@ class WazeOptionsFlow(config_entries.OptionsFlow):
) )
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN): class WazeConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Waze Travel Time.""" """Handle a config flow for Waze Travel Time."""
VERSION = 1 VERSION = 1
@ -117,12 +121,12 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
@staticmethod @staticmethod
@callback @callback
def async_get_options_flow( def async_get_options_flow(
config_entry: config_entries.ConfigEntry, config_entry: ConfigEntry,
) -> WazeOptionsFlow: ) -> WazeOptionsFlow:
"""Get the options flow for this handler.""" """Get the options flow for this handler."""
return WazeOptionsFlow(config_entry) return WazeOptionsFlow(config_entry)
async def async_step_user(self, user_input=None) -> FlowResult: async def async_step_user(self, user_input=None) -> ConfigFlowResult:
"""Handle the initial step.""" """Handle the initial step."""
errors = {} errors = {}
user_input = user_input or {} user_input = user_input or {}

7
homeassistant/components/weatherflow/config_flow.py
View file

@ -9,9 +9,8 @@ from typing import Any
from pyweatherflowudp.client import EVENT_DEVICE_DISCOVERED, WeatherFlowListener from pyweatherflowudp.client import EVENT_DEVICE_DISCOVERED, WeatherFlowListener
from pyweatherflowudp.errors import AddressInUseError, EndpointError, ListenerError from pyweatherflowudp.errors import AddressInUseError, EndpointError, ListenerError
from homeassistant import config_entries from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.core import callback from homeassistant.core import callback
from homeassistant.data_entry_flow import FlowResult
from .const import ( from .const import (
DOMAIN, DOMAIN,
@ -42,14 +41,14 @@ async def _async_can_discover_devices() -> bool:
return True return True
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN): class WeatherFlowConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for WeatherFlow.""" """Handle a config flow for WeatherFlow."""
VERSION = 1 VERSION = 1
async def async_step_user( async def async_step_user(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle a flow initialized by the user.""" """Handle a flow initialized by the user."""
# Only allow a single instance of integration since the listener # Only allow a single instance of integration since the listener

7
homeassistant/components/weatherflow_cloud/config_flow.py
View file

@ -10,7 +10,6 @@ from weatherflow4py.api import WeatherFlowRestAPI
from homeassistant import config_entries from homeassistant import config_entries
from homeassistant.const import CONF_API_TOKEN from homeassistant.const import CONF_API_TOKEN
from homeassistant.data_entry_flow import FlowResult
from .const import DOMAIN from .const import DOMAIN
@ -32,7 +31,9 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
VERSION = 1 VERSION = 1
async def async_step_reauth(self, user_input: Mapping[str, Any]) -> FlowResult: async def async_step_reauth(
self, user_input: Mapping[str, Any]
) -> config_entries.ConfigFlowResult:
"""Handle a flow for reauth.""" """Handle a flow for reauth."""
errors = {} errors = {}
@ -58,7 +59,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user( async def async_step_user(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> config_entries.ConfigFlowResult:
"""Handle a flow initialized by the user.""" """Handle a flow initialized by the user."""
errors = {} errors = {}

6
homeassistant/components/weatherkit/config_flow.py
View file

@ -12,7 +12,7 @@ from apple_weatherkit.client import (
) )
import voluptuous as vol import voluptuous as vol
from homeassistant import config_entries, data_entry_flow from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_LATITUDE, CONF_LOCATION, CONF_LONGITUDE from homeassistant.const import CONF_LATITUDE, CONF_LOCATION, CONF_LONGITUDE
from homeassistant.helpers.aiohttp_client import async_get_clientsession from homeassistant.helpers.aiohttp_client import async_get_clientsession
from homeassistant.helpers.selector import ( from homeassistant.helpers.selector import (
@ -53,7 +53,7 @@ class WeatherKitUnsupportedLocationError(Exception):
"""Error to indicate a location is unsupported.""" """Error to indicate a location is unsupported."""
class WeatherKitFlowHandler(config_entries.ConfigFlow, domain=DOMAIN): class WeatherKitFlowHandler(ConfigFlow, domain=DOMAIN):
"""Config flow for WeatherKit.""" """Config flow for WeatherKit."""
VERSION = 1 VERSION = 1
@ -61,7 +61,7 @@ class WeatherKitFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user( async def async_step_user(
self, self,
user_input: dict[str, Any] | None = None, user_input: dict[str, Any] | None = None,
) -> data_entry_flow.FlowResult: ) -> ConfigFlowResult:
"""Handle a flow initialized by the user.""" """Handle a flow initialized by the user."""
errors = {} errors = {}
if user_input is not None: if user_input is not None:

25
homeassistant/components/webostv/config_flow.py
View file

@ -10,10 +10,15 @@ from aiowebostv import WebOsTvPairError
import voluptuous as vol import voluptuous as vol
from homeassistant.components import ssdp from homeassistant.components import ssdp
from homeassistant.config_entries import ConfigEntry, ConfigFlow, OptionsFlow from homeassistant.config_entries import (
ConfigEntry,
ConfigFlow,
ConfigFlowResult,
OptionsFlow,
)
from homeassistant.const import CONF_CLIENT_SECRET, CONF_HOST, CONF_NAME from homeassistant.const import CONF_CLIENT_SECRET, CONF_HOST, CONF_NAME
from homeassistant.core import callback from homeassistant.core import callback
from homeassistant.data_entry_flow import AbortFlow, FlowResult from homeassistant.data_entry_flow import AbortFlow
from homeassistant.helpers import config_validation as cv from homeassistant.helpers import config_validation as cv
from . import async_control_connect, update_client_key from . import async_control_connect, update_client_key
@ -51,7 +56,7 @@ class FlowHandler(ConfigFlow, domain=DOMAIN):
async def async_step_user( async def async_step_user(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle a flow initialized by the user.""" """Handle a flow initialized by the user."""
errors: dict[str, str] = {} errors: dict[str, str] = {}
if user_input is not None: if user_input is not None:
@ -82,7 +87,7 @@ class FlowHandler(ConfigFlow, domain=DOMAIN):
async def async_step_pairing( async def async_step_pairing(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Display pairing form.""" """Display pairing form."""
self._async_check_configured_entry() self._async_check_configured_entry()
@ -107,7 +112,9 @@ class FlowHandler(ConfigFlow, domain=DOMAIN):
return self.async_show_form(step_id="pairing", errors=errors) return self.async_show_form(step_id="pairing", errors=errors)
async def async_step_ssdp(self, discovery_info: ssdp.SsdpServiceInfo) -> FlowResult: async def async_step_ssdp(
self, discovery_info: ssdp.SsdpServiceInfo
) -> ConfigFlowResult:
"""Handle a flow initialized by discovery.""" """Handle a flow initialized by discovery."""
assert discovery_info.ssdp_location assert discovery_info.ssdp_location
host = urlparse(discovery_info.ssdp_location).hostname host = urlparse(discovery_info.ssdp_location).hostname
@ -129,7 +136,9 @@ class FlowHandler(ConfigFlow, domain=DOMAIN):
self._uuid = uuid self._uuid = uuid
return await self.async_step_pairing() return await self.async_step_pairing()
async def async_step_reauth(self, entry_data: Mapping[str, Any]) -> FlowResult: async def async_step_reauth(
self, entry_data: Mapping[str, Any]
) -> ConfigFlowResult:
"""Perform reauth upon an WebOsTvPairError.""" """Perform reauth upon an WebOsTvPairError."""
self._host = entry_data[CONF_HOST] self._host = entry_data[CONF_HOST]
self._entry = self.hass.config_entries.async_get_entry(self.context["entry_id"]) self._entry = self.hass.config_entries.async_get_entry(self.context["entry_id"])
@ -137,7 +146,7 @@ class FlowHandler(ConfigFlow, domain=DOMAIN):
async def async_step_reauth_confirm( async def async_step_reauth_confirm(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Dialog that informs the user that reauth is required.""" """Dialog that informs the user that reauth is required."""
assert self._entry is not None assert self._entry is not None
@ -168,7 +177,7 @@ class OptionsFlowHandler(OptionsFlow):
async def async_step_init( async def async_step_init(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Manage the options.""" """Manage the options."""
errors = {} errors = {}
if user_input is not None: if user_input is not None:

5
homeassistant/components/wemo/config_flow.py
View file

@ -8,9 +8,8 @@ from typing import Any, get_type_hints
import pywemo import pywemo
import voluptuous as vol import voluptuous as vol
from homeassistant.config_entries import ConfigEntry, OptionsFlow from homeassistant.config_entries import ConfigEntry, ConfigFlowResult, OptionsFlow
from homeassistant.core import HomeAssistant, callback from homeassistant.core import HomeAssistant, callback
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers.config_entry_flow import DiscoveryFlowHandler from homeassistant.helpers.config_entry_flow import DiscoveryFlowHandler
from .const import DOMAIN from .const import DOMAIN
@ -45,7 +44,7 @@ class WemoOptionsFlow(OptionsFlow):
async def async_step_init( async def async_step_init(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Manage options for the WeMo component.""" """Manage options for the WeMo component."""
errors: dict[str, str] | None = None errors: dict[str, str] | None = None
if user_input is not None: if user_input is not None:

27
homeassistant/components/whirlpool/config_flow.py
View file

@ -11,9 +11,10 @@ from whirlpool.appliancesmanager import AppliancesManager
from whirlpool.auth import Auth from whirlpool.auth import Auth
from whirlpool.backendselector import BackendSelector from whirlpool.backendselector import BackendSelector
from homeassistant import config_entries, core, exceptions from homeassistant.config_entries import ConfigEntry, ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_PASSWORD, CONF_REGION, CONF_USERNAME from homeassistant.const import CONF_PASSWORD, CONF_REGION, CONF_USERNAME
from homeassistant.data_entry_flow import FlowResult from homeassistant.core import HomeAssistant
from homeassistant.exceptions import HomeAssistantError
from homeassistant.helpers.aiohttp_client import async_get_clientsession from homeassistant.helpers.aiohttp_client import async_get_clientsession
from .const import CONF_REGIONS_MAP, DOMAIN from .const import CONF_REGIONS_MAP, DOMAIN
@ -33,9 +34,7 @@ STEP_USER_DATA_SCHEMA = vol.Schema(
REAUTH_SCHEMA = vol.Schema({vol.Required(CONF_PASSWORD): str}) REAUTH_SCHEMA = vol.Schema({vol.Required(CONF_PASSWORD): str})
async def validate_input( async def validate_input(hass: HomeAssistant, data: dict[str, str]) -> dict[str, str]:
hass: core.HomeAssistant, data: dict[str, str]
) -> dict[str, str]:
"""Validate the user input allows us to connect. """Validate the user input allows us to connect.
Data has the keys from STEP_USER_DATA_SCHEMA with values provided by the user. Data has the keys from STEP_USER_DATA_SCHEMA with values provided by the user.
@ -61,13 +60,15 @@ async def validate_input(
return {"title": data[CONF_USERNAME]} return {"title": data[CONF_USERNAME]}
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN): class WhirlpoolConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Whirlpool Sixth Sense.""" """Handle a config flow for Whirlpool Sixth Sense."""
VERSION = 1 VERSION = 1
entry: config_entries.ConfigEntry | None entry: ConfigEntry | None
async def async_step_reauth(self, entry_data: Mapping[str, Any]) -> FlowResult: async def async_step_reauth(
self, entry_data: Mapping[str, Any]
) -> ConfigFlowResult:
"""Handle re-authentication with Whirlpool Sixth Sense.""" """Handle re-authentication with Whirlpool Sixth Sense."""
self.entry = self.hass.config_entries.async_get_entry(self.context["entry_id"]) self.entry = self.hass.config_entries.async_get_entry(self.context["entry_id"])
@ -75,7 +76,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_reauth_confirm( async def async_step_reauth_confirm(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Confirm re-authentication with Whirlpool Sixth Sense.""" """Confirm re-authentication with Whirlpool Sixth Sense."""
errors: dict[str, str] = {} errors: dict[str, str] = {}
@ -110,7 +111,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
errors=errors, errors=errors,
) )
async def async_step_user(self, user_input=None) -> FlowResult: async def async_step_user(self, user_input=None) -> ConfigFlowResult:
"""Handle the initial step.""" """Handle the initial step."""
if user_input is None: if user_input is None:
return self.async_show_form( return self.async_show_form(
@ -142,13 +143,13 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
) )
class CannotConnect(exceptions.HomeAssistantError): class CannotConnect(HomeAssistantError):
"""Error to indicate we cannot connect.""" """Error to indicate we cannot connect."""
class InvalidAuth(exceptions.HomeAssistantError): class InvalidAuth(HomeAssistantError):
"""Error to indicate there is invalid auth.""" """Error to indicate there is invalid auth."""
class NoAppliances(exceptions.HomeAssistantError): class NoAppliances(HomeAssistantError):
"""Error to indicate no supported appliances in the user account.""" """Error to indicate no supported appliances in the user account."""

5
homeassistant/components/whois/config_flow.py
View file

@ -12,9 +12,8 @@ from whois.exceptions import (
WhoisCommandFailed, WhoisCommandFailed,
) )
from homeassistant.config_entries import ConfigFlow from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_DOMAIN from homeassistant.const import CONF_DOMAIN
from homeassistant.data_entry_flow import FlowResult
from .const import DOMAIN from .const import DOMAIN
@ -28,7 +27,7 @@ class WhoisFlowHandler(ConfigFlow, domain=DOMAIN):
async def async_step_user( async def async_step_user(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle a flow initialized by the user.""" """Handle a flow initialized by the user."""
errors = {} errors = {}

10
homeassistant/components/wiffi/config_flow.py
View file

@ -9,14 +9,14 @@ import errno
import voluptuous as vol import voluptuous as vol
from wiffi import WiffiTcpServer from wiffi import WiffiTcpServer
from homeassistant import config_entries from homeassistant.config_entries import ConfigEntry, ConfigFlow, OptionsFlow
from homeassistant.const import CONF_PORT, CONF_TIMEOUT from homeassistant.const import CONF_PORT, CONF_TIMEOUT
from homeassistant.core import callback from homeassistant.core import callback
from .const import DEFAULT_PORT, DEFAULT_TIMEOUT, DOMAIN from .const import DEFAULT_PORT, DEFAULT_TIMEOUT, DOMAIN
class WiffiFlowHandler(config_entries.ConfigFlow, domain=DOMAIN): class WiffiFlowHandler(ConfigFlow, domain=DOMAIN):
"""Wiffi server setup config flow.""" """Wiffi server setup config flow."""
VERSION = 1 VERSION = 1
@ -24,7 +24,7 @@ class WiffiFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
@staticmethod @staticmethod
@callback @callback
def async_get_options_flow( def async_get_options_flow(
config_entry: config_entries.ConfigEntry, config_entry: ConfigEntry,
) -> OptionsFlowHandler: ) -> OptionsFlowHandler:
"""Create Wiffi server setup option flow.""" """Create Wiffi server setup option flow."""
return OptionsFlowHandler(config_entry) return OptionsFlowHandler(config_entry)
@ -67,10 +67,10 @@ class WiffiFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
) )
class OptionsFlowHandler(config_entries.OptionsFlow): class OptionsFlowHandler(OptionsFlow):
"""Wiffi server setup option flow.""" """Wiffi server setup option flow."""
def __init__(self, config_entry: config_entries.ConfigEntry) -> None: def __init__(self, config_entry: ConfigEntry) -> None:
"""Initialize options flow.""" """Initialize options flow."""
self.config_entry = config_entry self.config_entry = config_entry

7
homeassistant/components/wilight/config_flow.py
View file

@ -4,9 +4,8 @@ from urllib.parse import urlparse
import pywilight import pywilight
from homeassistant.components import ssdp from homeassistant.components import ssdp
from homeassistant.config_entries import ConfigFlow from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_HOST from homeassistant.const import CONF_HOST
from homeassistant.data_entry_flow import FlowResult
from . import DOMAIN from . import DOMAIN
@ -50,7 +49,9 @@ class WiLightFlowHandler(ConfigFlow, domain=DOMAIN):
} }
return self.async_create_entry(title=self._title, data=data) return self.async_create_entry(title=self._title, data=data)
async def async_step_ssdp(self, discovery_info: ssdp.SsdpServiceInfo) -> FlowResult: async def async_step_ssdp(
self, discovery_info: ssdp.SsdpServiceInfo
) -> ConfigFlowResult:
"""Handle a discovered WiLight.""" """Handle a discovered WiLight."""
# Filter out basic information # Filter out basic information
if ( if (

11
homeassistant/components/withings/config_flow.py
View file

@ -8,9 +8,8 @@ from typing import Any
from aiowithings import AuthScope from aiowithings import AuthScope
from homeassistant.components.webhook import async_generate_id from homeassistant.components.webhook import async_generate_id
from homeassistant.config_entries import ConfigEntry from homeassistant.config_entries import ConfigEntry, ConfigFlowResult
from homeassistant.const import CONF_TOKEN, CONF_WEBHOOK_ID from homeassistant.const import CONF_TOKEN, CONF_WEBHOOK_ID
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers import config_entry_oauth2_flow from homeassistant.helpers import config_entry_oauth2_flow
from .const import CONF_USE_WEBHOOK, DEFAULT_TITLE, DOMAIN from .const import CONF_USE_WEBHOOK, DEFAULT_TITLE, DOMAIN
@ -44,7 +43,9 @@ class WithingsFlowHandler(
) )
} }
async def async_step_reauth(self, entry_data: Mapping[str, Any]) -> FlowResult: async def async_step_reauth(
self, entry_data: Mapping[str, Any]
) -> ConfigFlowResult:
"""Perform reauth upon an API authentication error.""" """Perform reauth upon an API authentication error."""
self.reauth_entry = self.hass.config_entries.async_get_entry( self.reauth_entry = self.hass.config_entries.async_get_entry(
self.context["entry_id"] self.context["entry_id"]
@ -53,13 +54,13 @@ class WithingsFlowHandler(
async def async_step_reauth_confirm( async def async_step_reauth_confirm(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Confirm reauth dialog.""" """Confirm reauth dialog."""
if user_input is None: if user_input is None:
return self.async_show_form(step_id="reauth_confirm") return self.async_show_form(step_id="reauth_confirm")
return await self.async_step_user() return await self.async_step_user()
async def async_oauth_create_entry(self, data: dict[str, Any]) -> FlowResult: async def async_oauth_create_entry(self, data: dict[str, Any]) -> ConfigFlowResult:
"""Create an entry for the flow, or update existing entry.""" """Create an entry for the flow, or update existing entry."""
user_id = str(data[CONF_TOKEN]["userid"]) user_id = str(data[CONF_TOKEN]["userid"])
if not self.reauth_entry: if not self.reauth_entry:

18
homeassistant/components/wiz/config_flow.py
View file

@ -10,9 +10,9 @@ from pywizlight.exceptions import WizLightConnectionError, WizLightTimeOutError
import voluptuous as vol import voluptuous as vol
from homeassistant.components import dhcp, onboarding from homeassistant.components import dhcp, onboarding
from homeassistant.config_entries import ConfigFlow from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_HOST from homeassistant.const import CONF_HOST
from homeassistant.data_entry_flow import AbortFlow, FlowResult from homeassistant.data_entry_flow import AbortFlow
from homeassistant.util.network import is_ip_address from homeassistant.util.network import is_ip_address
from .const import DEFAULT_NAME, DISCOVER_SCAN_TIMEOUT, DOMAIN, WIZ_CONNECT_EXCEPTIONS from .const import DEFAULT_NAME, DISCOVER_SCAN_TIMEOUT, DOMAIN, WIZ_CONNECT_EXCEPTIONS
@ -36,7 +36,9 @@ class WizConfigFlow(ConfigFlow, domain=DOMAIN):
"""Initialize the config flow.""" """Initialize the config flow."""
self._discovered_devices: dict[str, DiscoveredBulb] = {} self._discovered_devices: dict[str, DiscoveredBulb] = {}
async def async_step_dhcp(self, discovery_info: dhcp.DhcpServiceInfo) -> FlowResult: async def async_step_dhcp(
self, discovery_info: dhcp.DhcpServiceInfo
) -> ConfigFlowResult:
"""Handle discovery via dhcp.""" """Handle discovery via dhcp."""
self._discovered_device = DiscoveredBulb( self._discovered_device = DiscoveredBulb(
discovery_info.ip, discovery_info.macaddress discovery_info.ip, discovery_info.macaddress
@ -45,14 +47,14 @@ class WizConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_integration_discovery( async def async_step_integration_discovery(
self, discovery_info: dict[str, str] self, discovery_info: dict[str, str]
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle integration discovery.""" """Handle integration discovery."""
self._discovered_device = DiscoveredBulb( self._discovered_device = DiscoveredBulb(
discovery_info["ip_address"], discovery_info["mac_address"] discovery_info["ip_address"], discovery_info["mac_address"]
) )
return await self._async_handle_discovery() return await self._async_handle_discovery()
async def _async_handle_discovery(self) -> FlowResult: async def _async_handle_discovery(self) -> ConfigFlowResult:
"""Handle any discovery.""" """Handle any discovery."""
device = self._discovered_device device = self._discovered_device
_LOGGER.debug("Discovered device: %s", device) _LOGGER.debug("Discovered device: %s", device)
@ -81,7 +83,7 @@ class WizConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_discovery_confirm( async def async_step_discovery_confirm(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Confirm discovery.""" """Confirm discovery."""
ip_address = self._discovered_device.ip_address ip_address = self._discovered_device.ip_address
if user_input is not None or not onboarding.async_is_onboarded(self.hass): if user_input is not None or not onboarding.async_is_onboarded(self.hass):
@ -104,7 +106,7 @@ class WizConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_pick_device( async def async_step_pick_device(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle the step to pick discovered device.""" """Handle the step to pick discovered device."""
if user_input is not None: if user_input is not None:
device = self._discovered_devices[user_input[CONF_DEVICE]] device = self._discovered_devices[user_input[CONF_DEVICE]]
@ -146,7 +148,7 @@ class WizConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_user( async def async_step_user(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle a flow initialized by the user.""" """Handle a flow initialized by the user."""
errors = {} errors = {}
if user_input is not None: if user_input is not None:

16
homeassistant/components/wled/config_flow.py
View file

@ -7,10 +7,14 @@ import voluptuous as vol
from wled import WLED, Device, WLEDConnectionError from wled import WLED, Device, WLEDConnectionError
from homeassistant.components import onboarding, zeroconf from homeassistant.components import onboarding, zeroconf
from homeassistant.config_entries import ConfigEntry, ConfigFlow, OptionsFlow from homeassistant.config_entries import (
ConfigEntry,
ConfigFlow,
ConfigFlowResult,
OptionsFlow,
)
from homeassistant.const import CONF_HOST, CONF_MAC from homeassistant.const import CONF_HOST, CONF_MAC
from homeassistant.core import callback from homeassistant.core import callback
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers.aiohttp_client import async_get_clientsession from homeassistant.helpers.aiohttp_client import async_get_clientsession
from .const import CONF_KEEP_MAIN_LIGHT, DEFAULT_KEEP_MAIN_LIGHT, DOMAIN from .const import CONF_KEEP_MAIN_LIGHT, DEFAULT_KEEP_MAIN_LIGHT, DOMAIN
@ -31,7 +35,7 @@ class WLEDFlowHandler(ConfigFlow, domain=DOMAIN):
async def async_step_user( async def async_step_user(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle a flow initiated by the user.""" """Handle a flow initiated by the user."""
errors = {} errors = {}
@ -64,7 +68,7 @@ class WLEDFlowHandler(ConfigFlow, domain=DOMAIN):
async def async_step_zeroconf( async def async_step_zeroconf(
self, discovery_info: zeroconf.ZeroconfServiceInfo self, discovery_info: zeroconf.ZeroconfServiceInfo
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle zeroconf discovery.""" """Handle zeroconf discovery."""
# Abort quick if the mac address is provided by discovery info # Abort quick if the mac address is provided by discovery info
if mac := discovery_info.properties.get(CONF_MAC): if mac := discovery_info.properties.get(CONF_MAC):
@ -95,7 +99,7 @@ class WLEDFlowHandler(ConfigFlow, domain=DOMAIN):
async def async_step_zeroconf_confirm( async def async_step_zeroconf_confirm(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle a flow initiated by zeroconf.""" """Handle a flow initiated by zeroconf."""
if user_input is not None or not onboarding.async_is_onboarded(self.hass): if user_input is not None or not onboarding.async_is_onboarded(self.hass):
return self.async_create_entry( return self.async_create_entry(
@ -126,7 +130,7 @@ class WLEDOptionsFlowHandler(OptionsFlow):
async def async_step_init( async def async_step_init(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Manage WLED options.""" """Manage WLED options."""
if user_input is not None: if user_input is not None:
return self.async_create_entry(title="", data=user_input) return self.async_create_entry(title="", data=user_input)

4
homeassistant/components/wolflink/config_flow.py
View file

@ -6,7 +6,7 @@ import voluptuous as vol
from wolf_comm.token_auth import InvalidAuth from wolf_comm.token_auth import InvalidAuth
from wolf_comm.wolf_client import WolfClient from wolf_comm.wolf_client import WolfClient
from homeassistant import config_entries from homeassistant.config_entries import ConfigFlow
from homeassistant.const import CONF_PASSWORD, CONF_USERNAME from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
from .const import DEVICE_GATEWAY, DEVICE_ID, DEVICE_NAME, DOMAIN from .const import DEVICE_GATEWAY, DEVICE_ID, DEVICE_NAME, DOMAIN
@ -18,7 +18,7 @@ USER_SCHEMA = vol.Schema(
) )
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN): class WolfLinkConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Wolf SmartSet Service.""" """Handle a config flow for Wolf SmartSet Service."""
VERSION = 1 VERSION = 1

9
homeassistant/components/workday/config_flow.py
View file

@ -10,11 +10,12 @@ import voluptuous as vol
from homeassistant.config_entries import ( from homeassistant.config_entries import (
ConfigEntry, ConfigEntry,
ConfigFlow, ConfigFlow,
ConfigFlowResult,
OptionsFlowWithConfigEntry, OptionsFlowWithConfigEntry,
) )
from homeassistant.const import CONF_COUNTRY, CONF_LANGUAGE, CONF_NAME from homeassistant.const import CONF_COUNTRY, CONF_LANGUAGE, CONF_NAME
from homeassistant.core import callback from homeassistant.core import callback
from homeassistant.data_entry_flow import AbortFlow, FlowResult from homeassistant.data_entry_flow import AbortFlow
from homeassistant.exceptions import HomeAssistantError from homeassistant.exceptions import HomeAssistantError
from homeassistant.helpers.selector import ( from homeassistant.helpers.selector import (
CountrySelector, CountrySelector,
@ -200,7 +201,7 @@ class WorkdayConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_user( async def async_step_user(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle the user initial step.""" """Handle the user initial step."""
errors: dict[str, str] = {} errors: dict[str, str] = {}
@ -228,7 +229,7 @@ class WorkdayConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_options( async def async_step_options(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle remaining flow.""" """Handle remaining flow."""
errors: dict[str, str] = {} errors: dict[str, str] = {}
if user_input is not None: if user_input is not None:
@ -290,7 +291,7 @@ class WorkdayOptionsFlowHandler(OptionsFlowWithConfigEntry):
async def async_step_init( async def async_step_init(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Manage Workday options.""" """Manage Workday options."""
errors: dict[str, str] = {} errors: dict[str, str] = {}

22
homeassistant/components/ws66i/config_flow.py
View file

@ -7,8 +7,10 @@ from typing import Any
from pyws66i import WS66i, get_ws66i from pyws66i import WS66i, get_ws66i
import voluptuous as vol import voluptuous as vol
from homeassistant import config_entries, core, exceptions from homeassistant.config_entries import ConfigEntry, ConfigFlow, OptionsFlow
from homeassistant.const import CONF_IP_ADDRESS from homeassistant.const import CONF_IP_ADDRESS
from homeassistant.core import HomeAssistant, callback
from homeassistant.exceptions import HomeAssistantError
from .const import ( from .const import (
CONF_SOURCE_1, CONF_SOURCE_1,
@ -40,7 +42,7 @@ DATA_SCHEMA = vol.Schema({vol.Required(CONF_IP_ADDRESS): str})
FIRST_ZONE = 11 FIRST_ZONE = 11
@core.callback @callback
def _sources_from_config(data): def _sources_from_config(data):
sources_config = { sources_config = {
str(idx + 1): data.get(source) for idx, source in enumerate(SOURCES) str(idx + 1): data.get(source) for idx, source in enumerate(SOURCES)
@ -70,7 +72,7 @@ def _verify_connection(ws66i: WS66i) -> bool:
async def validate_input( async def validate_input(
hass: core.HomeAssistant, input_data: dict[str, Any] hass: HomeAssistant, input_data: dict[str, Any]
) -> dict[str, Any]: ) -> dict[str, Any]:
"""Validate the user input. """Validate the user input.
@ -86,7 +88,7 @@ async def validate_input(
return {CONF_IP_ADDRESS: input_data[CONF_IP_ADDRESS]} return {CONF_IP_ADDRESS: input_data[CONF_IP_ADDRESS]}
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN): class WS66iConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for WS66i 6-Zone Amplifier.""" """Handle a config flow for WS66i 6-Zone Amplifier."""
VERSION = 1 VERSION = 1
@ -115,15 +117,15 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
) )
@staticmethod @staticmethod
@core.callback @callback
def async_get_options_flow( def async_get_options_flow(
config_entry: config_entries.ConfigEntry, config_entry: ConfigEntry,
) -> Ws66iOptionsFlowHandler: ) -> Ws66iOptionsFlowHandler:
"""Define the config flow to handle options.""" """Define the config flow to handle options."""
return Ws66iOptionsFlowHandler(config_entry) return Ws66iOptionsFlowHandler(config_entry)
@core.callback @callback
def _key_for_source(index, source, previous_sources): def _key_for_source(index, source, previous_sources):
key = vol.Required( key = vol.Required(
source, description={"suggested_value": previous_sources[str(index)]} source, description={"suggested_value": previous_sources[str(index)]}
@ -132,10 +134,10 @@ def _key_for_source(index, source, previous_sources):
return key return key
class Ws66iOptionsFlowHandler(config_entries.OptionsFlow): class Ws66iOptionsFlowHandler(OptionsFlow):
"""Handle a WS66i options flow.""" """Handle a WS66i options flow."""
def __init__(self, config_entry: config_entries.ConfigEntry) -> None: def __init__(self, config_entry: ConfigEntry) -> None:
"""Initialize.""" """Initialize."""
self.config_entry = config_entry self.config_entry = config_entry
@ -160,5 +162,5 @@ class Ws66iOptionsFlowHandler(config_entries.OptionsFlow):
) )
class CannotConnect(exceptions.HomeAssistantError): class CannotConnect(HomeAssistantError):
"""Error to indicate we cannot connect.""" """Error to indicate we cannot connect."""

15
homeassistant/components/wyoming/config_flow.py
View file

@ -7,10 +7,9 @@ from urllib.parse import urlparse
import voluptuous as vol import voluptuous as vol
from homeassistant import config_entries
from homeassistant.components import hassio, zeroconf from homeassistant.components import hassio, zeroconf
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_HOST, CONF_NAME, CONF_PORT from homeassistant.const import CONF_HOST, CONF_NAME, CONF_PORT
from homeassistant.data_entry_flow import FlowResult
from .const import DOMAIN from .const import DOMAIN
from .data import WyomingService from .data import WyomingService
@ -25,7 +24,7 @@ STEP_USER_DATA_SCHEMA = vol.Schema(
) )
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN): class WyomingConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Wyoming integration.""" """Handle a config flow for Wyoming integration."""
VERSION = 1 VERSION = 1
@ -36,7 +35,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user( async def async_step_user(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle the initial step.""" """Handle the initial step."""
if user_input is None: if user_input is None:
return self.async_show_form( return self.async_show_form(
@ -62,7 +61,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_hassio( async def async_step_hassio(
self, discovery_info: hassio.HassioServiceInfo self, discovery_info: hassio.HassioServiceInfo
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle Supervisor add-on discovery.""" """Handle Supervisor add-on discovery."""
_LOGGER.debug("Supervisor discovery info: %s", discovery_info) _LOGGER.debug("Supervisor discovery info: %s", discovery_info)
await self.async_set_unique_id(discovery_info.uuid) await self.async_set_unique_id(discovery_info.uuid)
@ -79,7 +78,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_hassio_confirm( async def async_step_hassio_confirm(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Confirm Supervisor discovery.""" """Confirm Supervisor discovery."""
errors: dict[str, str] = {} errors: dict[str, str] = {}
@ -104,7 +103,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_zeroconf( async def async_step_zeroconf(
self, discovery_info: zeroconf.ZeroconfServiceInfo self, discovery_info: zeroconf.ZeroconfServiceInfo
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle zeroconf discovery.""" """Handle zeroconf discovery."""
_LOGGER.debug("Zeroconf discovery info: %s", discovery_info) _LOGGER.debug("Zeroconf discovery info: %s", discovery_info)
if discovery_info.port is None: if discovery_info.port is None:
@ -131,7 +130,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_zeroconf_confirm( async def async_step_zeroconf_confirm(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle a flow initiated by zeroconf.""" """Handle a flow initiated by zeroconf."""
assert self._service is not None assert self._service is not None
assert self._name is not None assert self._name is not None

7
homeassistant/components/xiaomi_aqara/config_flow.py
View file

@ -5,11 +5,10 @@ from socket import gaierror
import voluptuous as vol import voluptuous as vol
from xiaomi_gateway import MULTICAST_PORT, XiaomiGateway, XiaomiGatewayDiscovery from xiaomi_gateway import MULTICAST_PORT, XiaomiGateway, XiaomiGatewayDiscovery
from homeassistant import config_entries
from homeassistant.components import zeroconf from homeassistant.components import zeroconf
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_HOST, CONF_MAC, CONF_NAME, CONF_PORT, CONF_PROTOCOL from homeassistant.const import CONF_HOST, CONF_MAC, CONF_NAME, CONF_PORT, CONF_PROTOCOL
from homeassistant.core import callback from homeassistant.core import callback
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers.device_registry import format_mac from homeassistant.helpers.device_registry import format_mac
from .const import ( from .const import (
@ -44,7 +43,7 @@ GATEWAY_SETTINGS = vol.Schema(
) )
class XiaomiAqaraFlowHandler(config_entries.ConfigFlow, domain=DOMAIN): class XiaomiAqaraFlowHandler(ConfigFlow, domain=DOMAIN):
"""Handle a Xiaomi Aqara config flow.""" """Handle a Xiaomi Aqara config flow."""
VERSION = 1 VERSION = 1
@ -148,7 +147,7 @@ class XiaomiAqaraFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_zeroconf( async def async_step_zeroconf(
self, discovery_info: zeroconf.ZeroconfServiceInfo self, discovery_info: zeroconf.ZeroconfServiceInfo
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle zeroconf discovery.""" """Handle zeroconf discovery."""
name = discovery_info.name name = discovery_info.name
self.host = discovery_info.host self.host = discovery_info.host

23
homeassistant/components/xiaomi_ble/config_flow.py
View file

@ -16,9 +16,8 @@ from homeassistant.components.bluetooth import (
async_discovered_service_info, async_discovered_service_info,
async_process_advertisements, async_process_advertisements,
) )
from homeassistant.config_entries import ConfigFlow from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_ADDRESS from homeassistant.const import CONF_ADDRESS
from homeassistant.data_entry_flow import FlowResult
from .const import DOMAIN from .const import DOMAIN
@ -76,7 +75,7 @@ class XiaomiConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_bluetooth( async def async_step_bluetooth(
self, discovery_info: BluetoothServiceInfo self, discovery_info: BluetoothServiceInfo
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle the bluetooth discovery step.""" """Handle the bluetooth discovery step."""
await self.async_set_unique_id(discovery_info.address) await self.async_set_unique_id(discovery_info.address)
self._abort_if_unique_id_configured() self._abort_if_unique_id_configured()
@ -109,7 +108,7 @@ class XiaomiConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_get_encryption_key_legacy( async def async_step_get_encryption_key_legacy(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Enter a legacy bindkey for a v2/v3 MiBeacon device.""" """Enter a legacy bindkey for a v2/v3 MiBeacon device."""
assert self._discovery_info assert self._discovery_info
assert self._discovered_device assert self._discovered_device
@ -143,7 +142,7 @@ class XiaomiConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_get_encryption_key_4_5( async def async_step_get_encryption_key_4_5(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Enter a bindkey for a v4/v5 MiBeacon device.""" """Enter a bindkey for a v4/v5 MiBeacon device."""
assert self._discovery_info assert self._discovery_info
assert self._discovered_device assert self._discovered_device
@ -177,7 +176,7 @@ class XiaomiConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_bluetooth_confirm( async def async_step_bluetooth_confirm(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Confirm discovery.""" """Confirm discovery."""
if user_input is not None or not onboarding.async_is_onboarded(self.hass): if user_input is not None or not onboarding.async_is_onboarded(self.hass):
return self._async_get_or_create_entry() return self._async_get_or_create_entry()
@ -190,7 +189,7 @@ class XiaomiConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_confirm_slow( async def async_step_confirm_slow(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Ack that device is slow.""" """Ack that device is slow."""
if user_input is not None: if user_input is not None:
return self._async_get_or_create_entry() return self._async_get_or_create_entry()
@ -203,7 +202,7 @@ class XiaomiConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_user( async def async_step_user(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle the user step to pick discovered device.""" """Handle the user step to pick discovered device."""
if user_input is not None: if user_input is not None:
address = user_input[CONF_ADDRESS] address = user_input[CONF_ADDRESS]
@ -260,7 +259,9 @@ class XiaomiConfigFlow(ConfigFlow, domain=DOMAIN):
data_schema=vol.Schema({vol.Required(CONF_ADDRESS): vol.In(titles)}), data_schema=vol.Schema({vol.Required(CONF_ADDRESS): vol.In(titles)}),
) )
async def async_step_reauth(self, entry_data: Mapping[str, Any]) -> FlowResult: async def async_step_reauth(
self, entry_data: Mapping[str, Any]
) -> ConfigFlowResult:
"""Handle a flow initialized by a reauth event.""" """Handle a flow initialized by a reauth event."""
entry = self.hass.config_entries.async_get_entry(self.context["entry_id"]) entry = self.hass.config_entries.async_get_entry(self.context["entry_id"])
assert entry is not None assert entry is not None
@ -279,7 +280,9 @@ class XiaomiConfigFlow(ConfigFlow, domain=DOMAIN):
# Otherwise there wasn't actually encryption so abort # Otherwise there wasn't actually encryption so abort
return self.async_abort(reason="reauth_successful") return self.async_abort(reason="reauth_successful")
def _async_get_or_create_entry(self, bindkey: str | None = None) -> FlowResult: def _async_get_or_create_entry(
self, bindkey: str | None = None
) -> ConfigFlowResult:
data: dict[str, Any] = {} data: dict[str, Any] = {}
if bindkey: if bindkey:

36
homeassistant/components/xiaomi_miio/config_flow.py
View file

@ -10,12 +10,16 @@ from micloud import MiCloud
from micloud.micloudexception import MiCloudAccessDenied from micloud.micloudexception import MiCloudAccessDenied
import voluptuous as vol import voluptuous as vol
from homeassistant import config_entries
from homeassistant.components import zeroconf from homeassistant.components import zeroconf
from homeassistant.config_entries import SOURCE_REAUTH, ConfigEntry from homeassistant.config_entries import (
SOURCE_REAUTH,
ConfigEntry,
ConfigFlow,
ConfigFlowResult,
OptionsFlow,
)
from homeassistant.const import CONF_DEVICE, CONF_HOST, CONF_MAC, CONF_MODEL, CONF_TOKEN from homeassistant.const import CONF_DEVICE, CONF_HOST, CONF_MAC, CONF_MODEL, CONF_TOKEN
from homeassistant.core import callback from homeassistant.core import callback
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers.device_registry import format_mac from homeassistant.helpers.device_registry import format_mac
from .const import ( from .const import (
@ -56,16 +60,16 @@ DEVICE_CLOUD_CONFIG = vol.Schema(
) )
class OptionsFlowHandler(config_entries.OptionsFlow): class OptionsFlowHandler(OptionsFlow):
"""Options for the component.""" """Options for the component."""
def __init__(self, config_entry: config_entries.ConfigEntry) -> None: def __init__(self, config_entry: ConfigEntry) -> None:
"""Init object.""" """Init object."""
self.config_entry = config_entry self.config_entry = config_entry
async def async_step_init( async def async_step_init(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Manage the options.""" """Manage the options."""
errors = {} errors = {}
if user_input is not None: if user_input is not None:
@ -104,7 +108,7 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
) )
class XiaomiMiioFlowHandler(config_entries.ConfigFlow, domain=DOMAIN): class XiaomiMiioFlowHandler(ConfigFlow, domain=DOMAIN):
"""Handle a Xiaomi Miio config flow.""" """Handle a Xiaomi Miio config flow."""
VERSION = 1 VERSION = 1
@ -127,7 +131,9 @@ class XiaomiMiioFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
"""Get the options flow.""" """Get the options flow."""
return OptionsFlowHandler(config_entry) return OptionsFlowHandler(config_entry)
async def async_step_reauth(self, entry_data: Mapping[str, Any]) -> FlowResult: async def async_step_reauth(
self, entry_data: Mapping[str, Any]
) -> ConfigFlowResult:
"""Perform reauth upon an authentication error or missing cloud credentials.""" """Perform reauth upon an authentication error or missing cloud credentials."""
self.host = entry_data[CONF_HOST] self.host = entry_data[CONF_HOST]
self.token = entry_data[CONF_TOKEN] self.token = entry_data[CONF_TOKEN]
@ -137,7 +143,7 @@ class XiaomiMiioFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_reauth_confirm( async def async_step_reauth_confirm(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Dialog that informs the user that reauth is required.""" """Dialog that informs the user that reauth is required."""
if user_input is not None: if user_input is not None:
return await self.async_step_cloud() return await self.async_step_cloud()
@ -145,13 +151,13 @@ class XiaomiMiioFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user( async def async_step_user(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle a flow initialized by the user.""" """Handle a flow initialized by the user."""
return await self.async_step_cloud() return await self.async_step_cloud()
async def async_step_zeroconf( async def async_step_zeroconf(
self, discovery_info: zeroconf.ZeroconfServiceInfo self, discovery_info: zeroconf.ZeroconfServiceInfo
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle zeroconf discovery.""" """Handle zeroconf discovery."""
name = discovery_info.name name = discovery_info.name
self.host = discovery_info.host self.host = discovery_info.host
@ -213,7 +219,7 @@ class XiaomiMiioFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_cloud( async def async_step_cloud(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Configure a xiaomi miio device through the Miio Cloud.""" """Configure a xiaomi miio device through the Miio Cloud."""
errors = {} errors = {}
if user_input is not None: if user_input is not None:
@ -290,7 +296,7 @@ class XiaomiMiioFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_select( async def async_step_select(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle multiple cloud devices found.""" """Handle multiple cloud devices found."""
errors: dict[str, str] = {} errors: dict[str, str] = {}
if user_input is not None: if user_input is not None:
@ -308,7 +314,7 @@ class XiaomiMiioFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_manual( async def async_step_manual(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Configure a xiaomi miio device Manually.""" """Configure a xiaomi miio device Manually."""
errors: dict[str, str] = {} errors: dict[str, str] = {}
if user_input is not None: if user_input is not None:
@ -327,7 +333,7 @@ class XiaomiMiioFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_connect( async def async_step_connect(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Connect to a xiaomi miio device.""" """Connect to a xiaomi miio device."""
errors: dict[str, str] = {} errors: dict[str, str] = {}
if self.host is None or self.token is None: if self.host is None or self.token is None:

18
homeassistant/components/yale_smart_alarm/config_flow.py
View file

@ -8,10 +8,14 @@ import voluptuous as vol
from yalesmartalarmclient.client import YaleSmartAlarmClient from yalesmartalarmclient.client import YaleSmartAlarmClient
from yalesmartalarmclient.exceptions import AuthenticationError from yalesmartalarmclient.exceptions import AuthenticationError
from homeassistant.config_entries import ConfigEntry, ConfigFlow, OptionsFlow from homeassistant.config_entries import (
ConfigEntry,
ConfigFlow,
ConfigFlowResult,
OptionsFlow,
)
from homeassistant.const import CONF_NAME, CONF_PASSWORD, CONF_USERNAME from homeassistant.const import CONF_NAME, CONF_PASSWORD, CONF_USERNAME
from homeassistant.core import callback from homeassistant.core import callback
from homeassistant.data_entry_flow import FlowResult
import homeassistant.helpers.config_validation as cv import homeassistant.helpers.config_validation as cv
from .const import ( from .const import (
@ -54,14 +58,16 @@ class YaleConfigFlow(ConfigFlow, domain=DOMAIN):
"""Get the options flow for this handler.""" """Get the options flow for this handler."""
return YaleOptionsFlowHandler(config_entry) return YaleOptionsFlowHandler(config_entry)
async def async_step_reauth(self, entry_data: Mapping[str, Any]) -> FlowResult: async def async_step_reauth(
self, entry_data: Mapping[str, Any]
) -> ConfigFlowResult:
"""Handle initiation of re-authentication with Yale.""" """Handle initiation of re-authentication with Yale."""
self.entry = self.hass.config_entries.async_get_entry(self.context["entry_id"]) self.entry = self.hass.config_entries.async_get_entry(self.context["entry_id"])
return await self.async_step_reauth_confirm() return await self.async_step_reauth_confirm()
async def async_step_reauth_confirm( async def async_step_reauth_confirm(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Dialog that informs the user that reauth is required.""" """Dialog that informs the user that reauth is required."""
errors = {} errors = {}
@ -102,7 +108,7 @@ class YaleConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_user( async def async_step_user(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle the initial step.""" """Handle the initial step."""
errors = {} errors = {}
@ -153,7 +159,7 @@ class YaleOptionsFlowHandler(OptionsFlow):
async def async_step_init( async def async_step_init(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Manage Yale options.""" """Manage Yale options."""
errors: dict[str, Any] = {} errors: dict[str, Any] = {}

39
homeassistant/components/yalexs_ble/config_flow.py
View file

@ -16,15 +16,20 @@ from yalexs_ble import (
) )
from yalexs_ble.const import YALE_MFR_ID from yalexs_ble.const import YALE_MFR_ID
from homeassistant import config_entries, data_entry_flow
from homeassistant.components.bluetooth import ( from homeassistant.components.bluetooth import (
BluetoothServiceInfoBleak, BluetoothServiceInfoBleak,
async_ble_device_from_address, async_ble_device_from_address,
async_discovered_service_info, async_discovered_service_info,
) )
from homeassistant.config_entries import (
ConfigEntry,
ConfigFlow,
ConfigFlowResult,
OptionsFlow,
)
from homeassistant.const import CONF_ADDRESS from homeassistant.const import CONF_ADDRESS
from homeassistant.core import callback from homeassistant.core import callback
from homeassistant.data_entry_flow import FlowResult from homeassistant.data_entry_flow import AbortFlow
from homeassistant.helpers.typing import DiscoveryInfoType from homeassistant.helpers.typing import DiscoveryInfoType
from .const import CONF_ALWAYS_CONNECTED, CONF_KEY, CONF_LOCAL_NAME, CONF_SLOT, DOMAIN from .const import CONF_ALWAYS_CONNECTED, CONF_KEY, CONF_LOCAL_NAME, CONF_SLOT, DOMAIN
@ -57,7 +62,7 @@ async def async_validate_lock_or_error(
return {} return {}
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN): class YalexsConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Yale Access Bluetooth.""" """Handle a config flow for Yale Access Bluetooth."""
VERSION = 1 VERSION = 1
@ -67,11 +72,11 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
self._discovery_info: BluetoothServiceInfoBleak | None = None self._discovery_info: BluetoothServiceInfoBleak | None = None
self._discovered_devices: dict[str, BluetoothServiceInfoBleak] = {} self._discovered_devices: dict[str, BluetoothServiceInfoBleak] = {}
self._lock_cfg: ValidatedLockConfig | None = None self._lock_cfg: ValidatedLockConfig | None = None
self._reauth_entry: config_entries.ConfigEntry | None = None self._reauth_entry: ConfigEntry | None = None
async def async_step_bluetooth( async def async_step_bluetooth(
self, discovery_info: BluetoothServiceInfoBleak self, discovery_info: BluetoothServiceInfoBleak
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle the bluetooth discovery step.""" """Handle the bluetooth discovery step."""
await self.async_set_unique_id(discovery_info.address) await self.async_set_unique_id(discovery_info.address)
self._abort_if_unique_id_configured() self._abort_if_unique_id_configured()
@ -86,7 +91,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_integration_discovery( async def async_step_integration_discovery(
self, discovery_info: DiscoveryInfoType self, discovery_info: DiscoveryInfoType
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle a discovered integration.""" """Handle a discovered integration."""
lock_cfg = ValidatedLockConfig( lock_cfg = ValidatedLockConfig(
discovery_info["name"], discovery_info["name"],
@ -137,7 +142,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
# and entered the keys. We abort the discovery flow since # and entered the keys. We abort the discovery flow since
# we assume they do not want to use the discovered keys for # we assume they do not want to use the discovered keys for
# some reason. # some reason.
raise data_entry_flow.AbortFlow("already_in_progress") raise AbortFlow("already_in_progress")
hass.config_entries.flow.async_abort(progress["flow_id"]) hass.config_entries.flow.async_abort(progress["flow_id"])
self._lock_cfg = lock_cfg self._lock_cfg = lock_cfg
@ -150,7 +155,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_integration_discovery_confirm( async def async_step_integration_discovery_confirm(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle a confirmation of discovered integration.""" """Handle a confirmation of discovered integration."""
assert self._discovery_info is not None assert self._discovery_info is not None
assert self._lock_cfg is not None assert self._lock_cfg is not None
@ -174,7 +179,9 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
}, },
) )
async def async_step_reauth(self, entry_data: Mapping[str, Any]) -> FlowResult: async def async_step_reauth(
self, entry_data: Mapping[str, Any]
) -> ConfigFlowResult:
"""Handle configuration by re-auth.""" """Handle configuration by re-auth."""
self._reauth_entry = self.hass.config_entries.async_get_entry( self._reauth_entry = self.hass.config_entries.async_get_entry(
self.context["entry_id"] self.context["entry_id"]
@ -183,7 +190,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_reauth_validate( async def async_step_reauth_validate(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle reauth and validation.""" """Handle reauth and validation."""
errors = {} errors = {}
reauth_entry = self._reauth_entry reauth_entry = self._reauth_entry
@ -221,7 +228,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user( async def async_step_user(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle the user step to pick discovered device.""" """Handle the user step to pick discovered device."""
errors: dict[str, str] = {} errors: dict[str, str] = {}
@ -296,28 +303,28 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
@staticmethod @staticmethod
@callback @callback
def async_get_options_flow( def async_get_options_flow(
config_entry: config_entries.ConfigEntry, config_entry: ConfigEntry,
) -> YaleXSBLEOptionsFlowHandler: ) -> YaleXSBLEOptionsFlowHandler:
"""Get the options flow for this handler.""" """Get the options flow for this handler."""
return YaleXSBLEOptionsFlowHandler(config_entry) return YaleXSBLEOptionsFlowHandler(config_entry)
class YaleXSBLEOptionsFlowHandler(config_entries.OptionsFlow): class YaleXSBLEOptionsFlowHandler(OptionsFlow):
"""Handle YaleXSBLE options.""" """Handle YaleXSBLE options."""
def __init__(self, config_entry: config_entries.ConfigEntry) -> None: def __init__(self, config_entry: ConfigEntry) -> None:
"""Initialize YaleXSBLE options flow.""" """Initialize YaleXSBLE options flow."""
self.entry = config_entry self.entry = config_entry
async def async_step_init( async def async_step_init(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Manage the YaleXSBLE options.""" """Manage the YaleXSBLE options."""
return await self.async_step_device_options() return await self.async_step_device_options()
async def async_step_device_options( async def async_step_device_options(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Manage the YaleXSBLE devices options.""" """Manage the YaleXSBLE devices options."""
if user_input is not None: if user_input is not None:
return self.async_create_entry( return self.async_create_entry(

10
homeassistant/components/yamaha_musiccast/config_flow.py
View file

@ -32,7 +32,7 @@ class MusicCastFlowHandler(ConfigFlow, domain=DOMAIN):
async def async_step_user( async def async_step_user(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> data_entry_flow.FlowResult: ) -> data_entry_flow.ConfigFlowResult:
"""Handle a flow initiated by the user.""" """Handle a flow initiated by the user."""
# Request user input, unless we are preparing discovery flow # Request user input, unless we are preparing discovery flow
if user_input is None: if user_input is None:
@ -74,7 +74,7 @@ class MusicCastFlowHandler(ConfigFlow, domain=DOMAIN):
def _show_setup_form( def _show_setup_form(
self, errors: dict | None = None self, errors: dict | None = None
) -> data_entry_flow.FlowResult: ) -> data_entry_flow.ConfigFlowResult:
"""Show the setup form to the user.""" """Show the setup form to the user."""
return self.async_show_form( return self.async_show_form(
step_id="user", step_id="user",
@ -84,7 +84,7 @@ class MusicCastFlowHandler(ConfigFlow, domain=DOMAIN):
async def async_step_ssdp( async def async_step_ssdp(
self, discovery_info: ssdp.SsdpServiceInfo self, discovery_info: ssdp.SsdpServiceInfo
) -> data_entry_flow.FlowResult: ) -> data_entry_flow.ConfigFlowResult:
"""Handle ssdp discoveries.""" """Handle ssdp discoveries."""
if not await MusicCastDevice.check_yamaha_ssdp( if not await MusicCastDevice.check_yamaha_ssdp(
discovery_info.ssdp_location, async_get_clientsession(self.hass) discovery_info.ssdp_location, async_get_clientsession(self.hass)
@ -116,7 +116,9 @@ class MusicCastFlowHandler(ConfigFlow, domain=DOMAIN):
return await self.async_step_confirm() return await self.async_step_confirm()
async def async_step_confirm(self, user_input=None) -> data_entry_flow.FlowResult: async def async_step_confirm(
self, user_input=None
) -> data_entry_flow.ConfigFlowResult:
"""Allow the user to confirm adding the device.""" """Allow the user to confirm adding the device."""
if user_input is not None: if user_input is not None:
return self.async_create_entry( return self.async_create_entry(

7
homeassistant/components/yardian/config_flow.py
View file

@ -12,9 +12,8 @@ from pyyardian import (
) )
import voluptuous as vol import voluptuous as vol
from homeassistant import config_entries from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_ACCESS_TOKEN, CONF_HOST from homeassistant.const import CONF_ACCESS_TOKEN, CONF_HOST
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers.aiohttp_client import async_get_clientsession from homeassistant.helpers.aiohttp_client import async_get_clientsession
from .const import DOMAIN, PRODUCT_NAME from .const import DOMAIN, PRODUCT_NAME
@ -29,7 +28,7 @@ STEP_USER_DATA_SCHEMA = vol.Schema(
) )
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN): class YardianConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Yardian.""" """Handle a config flow for Yardian."""
VERSION = 1 VERSION = 1
@ -45,7 +44,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user( async def async_step_user(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle the initial step.""" """Handle the initial step."""
errors: dict[str, str] = {} errors: dict[str, str] = {}
if user_input is not None: if user_input is not None:

29
homeassistant/components/yeelight/config_flow.py
View file

@ -9,12 +9,17 @@ import yeelight
from yeelight.aio import AsyncBulb from yeelight.aio import AsyncBulb
from yeelight.main import get_known_models from yeelight.main import get_known_models
from homeassistant import config_entries, exceptions
from homeassistant.components import dhcp, onboarding, ssdp, zeroconf from homeassistant.components import dhcp, onboarding, ssdp, zeroconf
from homeassistant.config_entries import ConfigEntry, ConfigEntryState from homeassistant.config_entries import (
ConfigEntry,
ConfigEntryState,
ConfigFlow,
ConfigFlowResult,
OptionsFlow,
)
from homeassistant.const import CONF_DEVICE, CONF_HOST, CONF_ID, CONF_MODEL, CONF_NAME from homeassistant.const import CONF_DEVICE, CONF_HOST, CONF_ID, CONF_MODEL, CONF_NAME
from homeassistant.core import callback from homeassistant.core import callback
from homeassistant.data_entry_flow import FlowResult from homeassistant.exceptions import HomeAssistantError
import homeassistant.helpers.config_validation as cv import homeassistant.helpers.config_validation as cv
from .const import ( from .const import (
@ -40,7 +45,7 @@ MODEL_UNKNOWN = "unknown"
_LOGGER = logging.getLogger(__name__) _LOGGER = logging.getLogger(__name__)
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN): class YeelightConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Yeelight.""" """Handle a config flow for Yeelight."""
VERSION = 1 VERSION = 1
@ -59,19 +64,21 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_homekit( async def async_step_homekit(
self, discovery_info: zeroconf.ZeroconfServiceInfo self, discovery_info: zeroconf.ZeroconfServiceInfo
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle discovery from homekit.""" """Handle discovery from homekit."""
self._discovered_ip = discovery_info.host self._discovered_ip = discovery_info.host
return await self._async_handle_discovery() return await self._async_handle_discovery()
async def async_step_dhcp(self, discovery_info: dhcp.DhcpServiceInfo) -> FlowResult: async def async_step_dhcp(
self, discovery_info: dhcp.DhcpServiceInfo
) -> ConfigFlowResult:
"""Handle discovery from dhcp.""" """Handle discovery from dhcp."""
self._discovered_ip = discovery_info.ip self._discovered_ip = discovery_info.ip
return await self._async_handle_discovery() return await self._async_handle_discovery()
async def async_step_zeroconf( async def async_step_zeroconf(
self, discovery_info: zeroconf.ZeroconfServiceInfo self, discovery_info: zeroconf.ZeroconfServiceInfo
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle discovery from zeroconf.""" """Handle discovery from zeroconf."""
self._discovered_ip = discovery_info.host self._discovered_ip = discovery_info.host
await self.async_set_unique_id( await self.async_set_unique_id(
@ -79,7 +86,9 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
) )
return await self._async_handle_discovery_with_unique_id() return await self._async_handle_discovery_with_unique_id()
async def async_step_ssdp(self, discovery_info: ssdp.SsdpServiceInfo) -> FlowResult: async def async_step_ssdp(
self, discovery_info: ssdp.SsdpServiceInfo
) -> ConfigFlowResult:
"""Handle discovery from ssdp.""" """Handle discovery from ssdp."""
self._discovered_ip = urlparse(discovery_info.ssdp_headers["location"]).hostname self._discovered_ip = urlparse(discovery_info.ssdp_headers["location"]).hostname
await self.async_set_unique_id(discovery_info.ssdp_headers["id"]) await self.async_set_unique_id(discovery_info.ssdp_headers["id"])
@ -272,7 +281,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
return MODEL_UNKNOWN return MODEL_UNKNOWN
class OptionsFlowHandler(config_entries.OptionsFlow): class OptionsFlowHandler(OptionsFlow):
"""Handle a option flow for Yeelight.""" """Handle a option flow for Yeelight."""
def __init__(self, config_entry: ConfigEntry) -> None: def __init__(self, config_entry: ConfigEntry) -> None:
@ -323,5 +332,5 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
) )
class CannotConnect(exceptions.HomeAssistantError): class CannotConnect(HomeAssistantError):
"""Error to indicate we cannot connect.""" """Error to indicate we cannot connect."""

13
homeassistant/components/yolink/config_flow.py
View file

@ -5,8 +5,7 @@ from collections.abc import Mapping
import logging import logging
from typing import Any from typing import Any
from homeassistant.config_entries import ConfigEntry from homeassistant.config_entries import ConfigEntry, ConfigFlowResult
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers import config_entry_oauth2_flow from homeassistant.helpers import config_entry_oauth2_flow
from .const import DOMAIN from .const import DOMAIN
@ -31,20 +30,22 @@ class OAuth2FlowHandler(
scopes = ["create"] scopes = ["create"]
return {"scope": " ".join(scopes)} return {"scope": " ".join(scopes)}
async def async_step_reauth(self, entry_data: Mapping[str, Any]) -> FlowResult: async def async_step_reauth(
self, entry_data: Mapping[str, Any]
) -> ConfigFlowResult:
"""Perform reauth upon an API authentication error.""" """Perform reauth upon an API authentication error."""
self._reauth_entry = self.hass.config_entries.async_get_entry( self._reauth_entry = self.hass.config_entries.async_get_entry(
self.context["entry_id"] self.context["entry_id"]
) )
return await self.async_step_reauth_confirm() return await self.async_step_reauth_confirm()
async def async_step_reauth_confirm(self, user_input=None) -> FlowResult: async def async_step_reauth_confirm(self, user_input=None) -> ConfigFlowResult:
"""Dialog that informs the user that reauth is required.""" """Dialog that informs the user that reauth is required."""
if user_input is None: if user_input is None:
return self.async_show_form(step_id="reauth_confirm") return self.async_show_form(step_id="reauth_confirm")
return await self.async_step_user() return await self.async_step_user()
async def async_oauth_create_entry(self, data: dict) -> FlowResult: async def async_oauth_create_entry(self, data: dict) -> ConfigFlowResult:
"""Create an oauth config entry or update existing entry for reauth.""" """Create an oauth config entry or update existing entry for reauth."""
if existing_entry := self._reauth_entry: if existing_entry := self._reauth_entry:
self.hass.config_entries.async_update_entry( self.hass.config_entries.async_update_entry(
@ -56,7 +57,7 @@ class OAuth2FlowHandler(
async def async_step_user( async def async_step_user(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle a flow start.""" """Handle a flow start."""
existing_entry = await self.async_set_unique_id(DOMAIN) existing_entry = await self.async_set_unique_id(DOMAIN)
if existing_entry and not self._reauth_entry: if existing_entry and not self._reauth_entry:

5
homeassistant/components/youless/config_flow.py
View file

@ -8,9 +8,8 @@ from urllib.error import HTTPError, URLError
import voluptuous as vol import voluptuous as vol
from youless_api import YoulessAPI from youless_api import YoulessAPI
from homeassistant.config_entries import ConfigFlow from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_DEVICE, CONF_HOST from homeassistant.const import CONF_DEVICE, CONF_HOST
from homeassistant.data_entry_flow import FlowResult
from .const import DOMAIN from .const import DOMAIN
@ -26,7 +25,7 @@ class YoulessConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_user( async def async_step_user(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle the initial step.""" """Handle the initial step."""
errors = {} errors = {}
if user_input is not None: if user_input is not None:

19
homeassistant/components/youtube/config_flow.py
View file

@ -10,10 +10,13 @@ from youtubeaio.helper import first
from youtubeaio.types import AuthScope, ForbiddenError from youtubeaio.types import AuthScope, ForbiddenError
from youtubeaio.youtube import YouTube from youtubeaio.youtube import YouTube
from homeassistant.config_entries import ConfigEntry, OptionsFlowWithConfigEntry from homeassistant.config_entries import (
ConfigEntry,
ConfigFlowResult,
OptionsFlowWithConfigEntry,
)
from homeassistant.const import CONF_ACCESS_TOKEN, CONF_TOKEN from homeassistant.const import CONF_ACCESS_TOKEN, CONF_TOKEN
from homeassistant.core import callback from homeassistant.core import callback
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers import config_entry_oauth2_flow from homeassistant.helpers import config_entry_oauth2_flow
from homeassistant.helpers.aiohttp_client import async_get_clientsession from homeassistant.helpers.aiohttp_client import async_get_clientsession
from homeassistant.helpers.selector import ( from homeassistant.helpers.selector import (
@ -67,7 +70,9 @@ class OAuth2FlowHandler(
"prompt": "consent", "prompt": "consent",
} }
async def async_step_reauth(self, entry_data: Mapping[str, Any]) -> FlowResult: async def async_step_reauth(
self, entry_data: Mapping[str, Any]
) -> ConfigFlowResult:
"""Perform reauth upon an API authentication error.""" """Perform reauth upon an API authentication error."""
self.reauth_entry = self.hass.config_entries.async_get_entry( self.reauth_entry = self.hass.config_entries.async_get_entry(
self.context["entry_id"] self.context["entry_id"]
@ -76,7 +81,7 @@ class OAuth2FlowHandler(
async def async_step_reauth_confirm( async def async_step_reauth_confirm(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Confirm reauth dialog.""" """Confirm reauth dialog."""
if user_input is None: if user_input is None:
return self.async_show_form(step_id="reauth_confirm") return self.async_show_form(step_id="reauth_confirm")
@ -89,7 +94,7 @@ class OAuth2FlowHandler(
await self._youtube.set_user_authentication(token, [AuthScope.READ_ONLY]) await self._youtube.set_user_authentication(token, [AuthScope.READ_ONLY])
return self._youtube return self._youtube
async def async_oauth_create_entry(self, data: dict[str, Any]) -> FlowResult: async def async_oauth_create_entry(self, data: dict[str, Any]) -> ConfigFlowResult:
"""Create an entry for the flow, or update existing entry.""" """Create an entry for the flow, or update existing entry."""
try: try:
youtube = await self.get_resource(data[CONF_TOKEN][CONF_ACCESS_TOKEN]) youtube = await self.get_resource(data[CONF_TOKEN][CONF_ACCESS_TOKEN])
@ -129,7 +134,7 @@ class OAuth2FlowHandler(
async def async_step_channels( async def async_step_channels(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Select which channels to track.""" """Select which channels to track."""
if user_input: if user_input:
return self.async_create_entry( return self.async_create_entry(
@ -164,7 +169,7 @@ class YouTubeOptionsFlowHandler(OptionsFlowWithConfigEntry):
async def async_step_init( async def async_step_init(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Initialize form.""" """Initialize form."""
if user_input is not None: if user_input is not None:
return self.async_create_entry( return self.async_create_entry(

7
homeassistant/components/zamg/config_flow.py
View file

@ -7,14 +7,13 @@ import voluptuous as vol
from zamg import ZamgData from zamg import ZamgData
from zamg.exceptions import ZamgApiError, ZamgNoDataError from zamg.exceptions import ZamgApiError, ZamgNoDataError
from homeassistant import config_entries from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers.aiohttp_client import async_get_clientsession from homeassistant.helpers.aiohttp_client import async_get_clientsession
from .const import CONF_STATION_ID, DOMAIN, LOGGER from .const import CONF_STATION_ID, DOMAIN, LOGGER
class ZamgConfigFlow(config_entries.ConfigFlow, domain=DOMAIN): class ZamgConfigFlow(ConfigFlow, domain=DOMAIN):
"""Config flow for zamg integration.""" """Config flow for zamg integration."""
VERSION = 1 VERSION = 1
@ -23,7 +22,7 @@ class ZamgConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user( async def async_step_user(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle a flow initiated by the user.""" """Handle a flow initiated by the user."""
if self._client is None: if self._client is None:
self._client = ZamgData() self._client = ZamgData()

7
homeassistant/components/zeversolar/config_flow.py
View file

@ -7,9 +7,8 @@ from typing import Any
import voluptuous as vol import voluptuous as vol
import zeversolar import zeversolar
from homeassistant import config_entries from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_HOST from homeassistant.const import CONF_HOST
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers import config_validation as cv from homeassistant.helpers import config_validation as cv
from .const import DOMAIN from .const import DOMAIN
@ -23,14 +22,14 @@ STEP_USER_DATA_SCHEMA = vol.Schema(
) )
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN): class ZeverSolarConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for zeversolar.""" """Handle a config flow for zeversolar."""
VERSION = 1 VERSION = 1
async def async_step_user( async def async_step_user(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle the initial step.""" """Handle the initial step."""
if user_input is None: if user_input is None:
return self.async_show_form( return self.async_show_form(

81
homeassistant/components/zha/config_flow.py
View file

@ -12,15 +12,24 @@ import voluptuous as vol
import zigpy.backups import zigpy.backups
from zigpy.config import CONF_DEVICE, CONF_DEVICE_PATH from zigpy.config import CONF_DEVICE, CONF_DEVICE_PATH
from homeassistant import config_entries
from homeassistant.components import onboarding, usb, zeroconf from homeassistant.components import onboarding, usb, zeroconf
from homeassistant.components.file_upload import process_uploaded_file from homeassistant.components.file_upload import process_uploaded_file
from homeassistant.components.hassio import AddonError, AddonState from homeassistant.components.hassio import AddonError, AddonState
from homeassistant.components.homeassistant_hardware import silabs_multiprotocol_addon from homeassistant.components.homeassistant_hardware import silabs_multiprotocol_addon
from homeassistant.components.homeassistant_yellow import hardware as yellow_hardware from homeassistant.components.homeassistant_yellow import hardware as yellow_hardware
from homeassistant.config_entries import (
SOURCE_IGNORE,
SOURCE_ZEROCONF,
ConfigEntry,
ConfigEntryBaseFlow,
ConfigEntryState,
ConfigFlow,
ConfigFlowResult,
OperationNotAllowed,
OptionsFlow,
)
from homeassistant.const import CONF_NAME from homeassistant.const import CONF_NAME
from homeassistant.core import HomeAssistant, callback from homeassistant.core import HomeAssistant, callback
from homeassistant.data_entry_flow import FlowHandler, FlowResult
from homeassistant.exceptions import HomeAssistantError from homeassistant.exceptions import HomeAssistantError
from homeassistant.helpers.selector import FileSelector, FileSelectorConfig from homeassistant.helpers.selector import FileSelector, FileSelectorConfig
from homeassistant.util import dt as dt_util from homeassistant.util import dt as dt_util
@ -122,7 +131,7 @@ async def list_serial_ports(hass: HomeAssistant) -> list[ListPortInfo]:
return ports return ports
class BaseZhaFlow(FlowHandler): class BaseZhaFlow(ConfigEntryBaseFlow):
"""Mixin for common ZHA flow steps and forms.""" """Mixin for common ZHA flow steps and forms."""
_hass: HomeAssistant _hass: HomeAssistant
@ -146,7 +155,7 @@ class BaseZhaFlow(FlowHandler):
self._hass = hass self._hass = hass
self._radio_mgr.hass = hass self._radio_mgr.hass = hass
async def _async_create_radio_entry(self) -> FlowResult: async def _async_create_radio_entry(self) -> ConfigFlowResult:
"""Create a config entry with the current flow state.""" """Create a config entry with the current flow state."""
assert self._title is not None assert self._title is not None
assert self._radio_mgr.radio_type is not None assert self._radio_mgr.radio_type is not None
@ -168,7 +177,7 @@ class BaseZhaFlow(FlowHandler):
async def async_step_choose_serial_port( async def async_step_choose_serial_port(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Choose a serial port.""" """Choose a serial port."""
ports = await list_serial_ports(self.hass) ports = await list_serial_ports(self.hass)
list_of_ports = [ list_of_ports = [
@ -232,7 +241,7 @@ class BaseZhaFlow(FlowHandler):
async def async_step_manual_pick_radio_type( async def async_step_manual_pick_radio_type(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Manually select the radio type.""" """Manually select the radio type."""
if user_input is not None: if user_input is not None:
self._radio_mgr.radio_type = RadioType.get_by_description( self._radio_mgr.radio_type = RadioType.get_by_description(
@ -257,7 +266,7 @@ class BaseZhaFlow(FlowHandler):
async def async_step_manual_port_config( async def async_step_manual_port_config(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Enter port settings specific for this type of radio.""" """Enter port settings specific for this type of radio."""
assert self._radio_mgr.radio_type is not None assert self._radio_mgr.radio_type is not None
errors = {} errors = {}
@ -286,7 +295,7 @@ class BaseZhaFlow(FlowHandler):
if param not in SUPPORTED_PORT_SETTINGS: if param not in SUPPORTED_PORT_SETTINGS:
continue continue
if source == config_entries.SOURCE_ZEROCONF and param == CONF_BAUDRATE: if source == SOURCE_ZEROCONF and param == CONF_BAUDRATE:
value = 115200 value = 115200
param = vol.Required(CONF_BAUDRATE, default=value) param = vol.Required(CONF_BAUDRATE, default=value)
elif ( elif (
@ -307,7 +316,7 @@ class BaseZhaFlow(FlowHandler):
async def async_step_verify_radio( async def async_step_verify_radio(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Add a warning step to dissuade the use of deprecated radios.""" """Add a warning step to dissuade the use of deprecated radios."""
assert self._radio_mgr.radio_type is not None assert self._radio_mgr.radio_type is not None
@ -327,7 +336,7 @@ class BaseZhaFlow(FlowHandler):
async def async_step_choose_formation_strategy( async def async_step_choose_formation_strategy(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Choose how to deal with the current radio's settings.""" """Choose how to deal with the current radio's settings."""
await self._radio_mgr.async_load_network_settings() await self._radio_mgr.async_load_network_settings()
@ -370,20 +379,20 @@ class BaseZhaFlow(FlowHandler):
async def async_step_reuse_settings( async def async_step_reuse_settings(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Reuse the existing network settings on the stick.""" """Reuse the existing network settings on the stick."""
return await self._async_create_radio_entry() return await self._async_create_radio_entry()
async def async_step_form_initial_network( async def async_step_form_initial_network(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Form an initial network.""" """Form an initial network."""
# This step exists only for translations, it does nothing new # This step exists only for translations, it does nothing new
return await self.async_step_form_new_network(user_input) return await self.async_step_form_new_network(user_input)
async def async_step_form_new_network( async def async_step_form_new_network(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Form a brand-new network.""" """Form a brand-new network."""
await self._radio_mgr.async_form_network() await self._radio_mgr.async_form_network()
return await self._async_create_radio_entry() return await self._async_create_radio_entry()
@ -399,7 +408,7 @@ class BaseZhaFlow(FlowHandler):
async def async_step_upload_manual_backup( async def async_step_upload_manual_backup(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Upload and restore a coordinator backup JSON file.""" """Upload and restore a coordinator backup JSON file."""
errors = {} errors = {}
@ -427,7 +436,7 @@ class BaseZhaFlow(FlowHandler):
async def async_step_choose_automatic_backup( async def async_step_choose_automatic_backup(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Choose an automatic backup.""" """Choose an automatic backup."""
if self.show_advanced_options: if self.show_advanced_options:
# Always show the PAN IDs when in advanced mode # Always show the PAN IDs when in advanced mode
@ -466,7 +475,7 @@ class BaseZhaFlow(FlowHandler):
async def async_step_maybe_confirm_ezsp_restore( async def async_step_maybe_confirm_ezsp_restore(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Confirm restore for EZSP radios that require permanent IEEE writes.""" """Confirm restore for EZSP radios that require permanent IEEE writes."""
call_step_2 = await self._radio_mgr.async_restore_backup_step_1() call_step_2 = await self._radio_mgr.async_restore_backup_step_1()
if not call_step_2: if not call_step_2:
@ -486,7 +495,7 @@ class BaseZhaFlow(FlowHandler):
) )
class ZhaConfigFlowHandler(BaseZhaFlow, config_entries.ConfigFlow, domain=DOMAIN): class ZhaConfigFlowHandler(BaseZhaFlow, ConfigFlow, domain=DOMAIN):
"""Handle a config flow.""" """Handle a config flow."""
VERSION = 4 VERSION = 4
@ -512,14 +521,14 @@ class ZhaConfigFlowHandler(BaseZhaFlow, config_entries.ConfigFlow, domain=DOMAIN
@staticmethod @staticmethod
@callback @callback
def async_get_options_flow( def async_get_options_flow(
config_entry: config_entries.ConfigEntry, config_entry: ConfigEntry,
) -> config_entries.OptionsFlow: ) -> OptionsFlow:
"""Create the options flow.""" """Create the options flow."""
return ZhaOptionsFlowHandler(config_entry) return ZhaOptionsFlowHandler(config_entry)
async def async_step_user( async def async_step_user(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle a ZHA config flow start.""" """Handle a ZHA config flow start."""
if self._async_current_entries(): if self._async_current_entries():
return self.async_abort(reason="single_instance_allowed") return self.async_abort(reason="single_instance_allowed")
@ -528,7 +537,7 @@ class ZhaConfigFlowHandler(BaseZhaFlow, config_entries.ConfigFlow, domain=DOMAIN
async def async_step_confirm( async def async_step_confirm(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Confirm a discovery.""" """Confirm a discovery."""
self._set_confirm_only() self._set_confirm_only()
@ -566,7 +575,9 @@ class ZhaConfigFlowHandler(BaseZhaFlow, config_entries.ConfigFlow, domain=DOMAIN
description_placeholders={CONF_NAME: self._title}, description_placeholders={CONF_NAME: self._title},
) )
async def async_step_usb(self, discovery_info: usb.UsbServiceInfo) -> FlowResult: async def async_step_usb(
self, discovery_info: usb.UsbServiceInfo
) -> ConfigFlowResult:
"""Handle usb discovery.""" """Handle usb discovery."""
vid = discovery_info.vid vid = discovery_info.vid
pid = discovery_info.pid pid = discovery_info.pid
@ -585,7 +596,7 @@ class ZhaConfigFlowHandler(BaseZhaFlow, config_entries.ConfigFlow, domain=DOMAIN
if self.hass.config_entries.flow.async_progress_by_handler(DECONZ_DOMAIN): if self.hass.config_entries.flow.async_progress_by_handler(DECONZ_DOMAIN):
return self.async_abort(reason="not_zha_device") return self.async_abort(reason="not_zha_device")
for entry in self.hass.config_entries.async_entries(DECONZ_DOMAIN): for entry in self.hass.config_entries.async_entries(DECONZ_DOMAIN):
if entry.source != config_entries.SOURCE_IGNORE: if entry.source != SOURCE_IGNORE:
return self.async_abort(reason="not_zha_device") return self.async_abort(reason="not_zha_device")
self._radio_mgr.device_path = dev_path self._radio_mgr.device_path = dev_path
@ -602,7 +613,7 @@ class ZhaConfigFlowHandler(BaseZhaFlow, config_entries.ConfigFlow, domain=DOMAIN
async def async_step_zeroconf( async def async_step_zeroconf(
self, discovery_info: zeroconf.ZeroconfServiceInfo self, discovery_info: zeroconf.ZeroconfServiceInfo
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle zeroconf discovery.""" """Handle zeroconf discovery."""
# Hostname is format: livingroom.local. # Hostname is format: livingroom.local.
@ -638,7 +649,7 @@ class ZhaConfigFlowHandler(BaseZhaFlow, config_entries.ConfigFlow, domain=DOMAIN
async def async_step_hardware( async def async_step_hardware(
self, data: dict[str, Any] | None = None self, data: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle hardware flow.""" """Handle hardware flow."""
try: try:
discovery_data = HARDWARE_DISCOVERY_SCHEMA(data) discovery_data = HARDWARE_DISCOVERY_SCHEMA(data)
@ -664,10 +675,10 @@ class ZhaConfigFlowHandler(BaseZhaFlow, config_entries.ConfigFlow, domain=DOMAIN
return await self.async_step_confirm() return await self.async_step_confirm()
class ZhaOptionsFlowHandler(BaseZhaFlow, config_entries.OptionsFlow): class ZhaOptionsFlowHandler(BaseZhaFlow, OptionsFlow):
"""Handle an options flow.""" """Handle an options flow."""
def __init__(self, config_entry: config_entries.ConfigEntry) -> None: def __init__(self, config_entry: ConfigEntry) -> None:
"""Initialize options flow.""" """Initialize options flow."""
super().__init__() super().__init__()
self.config_entry = config_entry self.config_entry = config_entry
@ -679,11 +690,11 @@ class ZhaOptionsFlowHandler(BaseZhaFlow, config_entries.OptionsFlow):
async def async_step_init( async def async_step_init(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Launch the options flow.""" """Launch the options flow."""
if user_input is not None: if user_input is not None:
# OperationNotAllowed: ZHA is not running # OperationNotAllowed: ZHA is not running
with suppress(config_entries.OperationNotAllowed): with suppress(OperationNotAllowed):
await self.hass.config_entries.async_unload(self.config_entry.entry_id) await self.hass.config_entries.async_unload(self.config_entry.entry_id)
return await self.async_step_prompt_migrate_or_reconfigure() return await self.async_step_prompt_migrate_or_reconfigure()
@ -692,7 +703,7 @@ class ZhaOptionsFlowHandler(BaseZhaFlow, config_entries.OptionsFlow):
async def async_step_prompt_migrate_or_reconfigure( async def async_step_prompt_migrate_or_reconfigure(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Confirm if we are migrating adapters or just re-configuring.""" """Confirm if we are migrating adapters or just re-configuring."""
return self.async_show_menu( return self.async_show_menu(
@ -705,13 +716,13 @@ class ZhaOptionsFlowHandler(BaseZhaFlow, config_entries.OptionsFlow):
async def async_step_intent_reconfigure( async def async_step_intent_reconfigure(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Virtual step for when the user is reconfiguring the integration.""" """Virtual step for when the user is reconfiguring the integration."""
return await self.async_step_choose_serial_port() return await self.async_step_choose_serial_port()
async def async_step_intent_migrate( async def async_step_intent_migrate(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Confirm the user wants to reset their current radio.""" """Confirm the user wants to reset their current radio."""
if user_input is not None: if user_input is not None:
@ -723,7 +734,7 @@ class ZhaOptionsFlowHandler(BaseZhaFlow, config_entries.OptionsFlow):
async def async_step_instruct_unplug( async def async_step_instruct_unplug(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Instruct the user to unplug the current radio, if possible.""" """Instruct the user to unplug the current radio, if possible."""
if user_input is not None: if user_input is not None:
@ -758,8 +769,8 @@ class ZhaOptionsFlowHandler(BaseZhaFlow, config_entries.OptionsFlow):
def async_remove(self): def async_remove(self):
"""Maybe reload ZHA if the flow is aborted.""" """Maybe reload ZHA if the flow is aborted."""
if self.config_entry.state not in ( if self.config_entry.state not in (
config_entries.ConfigEntryState.SETUP_ERROR, ConfigEntryState.SETUP_ERROR,
config_entries.ConfigEntryState.NOT_LOADED, ConfigEntryState.NOT_LOADED,
): ):
return return

5
homeassistant/components/zodiac/config_flow.py
View file

@ -3,8 +3,7 @@ from __future__ import annotations
from typing import Any from typing import Any
from homeassistant.config_entries import ConfigFlow from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.data_entry_flow import FlowResult
from .const import DEFAULT_NAME, DOMAIN from .const import DEFAULT_NAME, DOMAIN
@ -16,7 +15,7 @@ class ZodiacConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_user( async def async_step_user(
self, user_input: dict[str, Any] | None = None self, user_input: dict[str, Any] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle a flow initialized by the user.""" """Handle a flow initialized by the user."""
if self._async_current_entries(): if self._async_current_entries():
return self.async_abort(reason="single_instance_allowed") return self.async_abort(reason="single_instance_allowed")

4
homeassistant/components/zone/config_flow.py
View file

@ -4,10 +4,10 @@ This is no longer in use. This file is around so that existing
config entries will remain to be loaded and then automatically config entries will remain to be loaded and then automatically
migrated to the storage collection. migrated to the storage collection.
""" """
from homeassistant import config_entries from homeassistant.config_entries import ConfigFlow
from .const import DOMAIN from .const import DOMAIN
class ZoneConfigFlow(config_entries.ConfigFlow, domain=DOMAIN): class ZoneConfigFlow(ConfigFlow, domain=DOMAIN):
"""Stub zone config flow class.""" """Stub zone config flow class."""

9
homeassistant/components/zwave_me/config_flow.py
View file

@ -6,10 +6,9 @@ import logging
from url_normalize import url_normalize from url_normalize import url_normalize
import voluptuous as vol import voluptuous as vol
from homeassistant import config_entries
from homeassistant.components.zeroconf import ZeroconfServiceInfo from homeassistant.components.zeroconf import ZeroconfServiceInfo
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_TOKEN, CONF_URL from homeassistant.const import CONF_TOKEN, CONF_URL
from homeassistant.data_entry_flow import FlowResult
from . import helpers from . import helpers
from .const import DOMAIN from .const import DOMAIN
@ -17,7 +16,7 @@ from .const import DOMAIN
_LOGGER = logging.getLogger(__name__) _LOGGER = logging.getLogger(__name__)
class ZWaveMeConfigFlow(config_entries.ConfigFlow, domain=DOMAIN): class ZWaveMeConfigFlow(ConfigFlow, domain=DOMAIN):
"""ZWaveMe integration config flow.""" """ZWaveMe integration config flow."""
def __init__(self) -> None: def __init__(self) -> None:
@ -28,7 +27,7 @@ class ZWaveMeConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user( async def async_step_user(
self, user_input: dict[str, str] | None = None self, user_input: dict[str, str] | None = None
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle a flow initialized by the user or started with zeroconf.""" """Handle a flow initialized by the user or started with zeroconf."""
errors = {} errors = {}
placeholders = { placeholders = {
@ -88,7 +87,7 @@ class ZWaveMeConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_zeroconf( async def async_step_zeroconf(
self, discovery_info: ZeroconfServiceInfo self, discovery_info: ZeroconfServiceInfo
) -> FlowResult: ) -> ConfigFlowResult:
"""Handle a discovered Z-Wave accessory - get url to pass into user step. """Handle a discovered Z-Wave accessory - get url to pass into user step.
This flow is triggered by the discovery component. This flow is triggered by the discovery component.

2
tests/components/wallbox/test_config_flow.py
View file

@ -42,7 +42,7 @@ test_response = json.loads(
async def test_show_set_form(hass: HomeAssistant) -> None: async def test_show_set_form(hass: HomeAssistant) -> None:
"""Test that the setup form is served.""" """Test that the setup form is served."""
flow = config_flow.ConfigFlow() flow = config_flow.WallboxConfigFlow()
flow.hass = hass flow.hass = hass
result = await flow.async_step_user(user_input=None) result = await flow.async_step_user(user_input=None)