Home-Assistant
/
core
mirror of https://github.com/home-assistant/core.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Migrate integrations n-r to generic flowhandler (#111864)

pull/111876/head^2
Erik Montnemery 2024-02-29 20:09:01 +01:00 committed by GitHub
parent 52e7912caf
commit e0c1feb22c
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
113 changed files with 890 additions and 746 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
homeassistant/components/nam/config_flow.py
View File

@ -17,11 +17,10 @@ from nettigo_air_monitor import (
)
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.components import zeroconf
from homeassistant.config_entries import ConfigEntry, ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
from homeassistant.core import HomeAssistant
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers.aiohttp_client import async_get_clientsession
from homeassistant.helpers.device_registry import format_mac
@ -70,7 +69,7 @@ async def async_check_credentials(
await nam.async_check_credentials()
class NAMFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
class NAMFlowHandler(ConfigFlow, domain=DOMAIN):
"""Config flow for Nettigo Air Monitor."""
VERSION = 1
@ -78,12 +77,12 @@ class NAMFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
def __init__(self) -> None:
"""Initialize flow."""
self.host: str
self.entry: config_entries.ConfigEntry
self.entry: ConfigEntry
self._config: NamConfig
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle a flow initialized by the user."""
errors: dict[str, str] = {}
@ -119,7 +118,7 @@ class NAMFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_credentials(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the credentials step."""
errors: dict[str, str] = {}
@ -145,7 +144,7 @@ class NAMFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_zeroconf(
self, discovery_info: zeroconf.ZeroconfServiceInfo
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle zeroconf discovery."""
self.host = discovery_info.host
self.context["title_placeholders"] = {"host": self.host}
@ -167,7 +166,7 @@ class NAMFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_confirm_discovery(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle discovery confirm."""
errors: dict[str, str] = {}
@ -188,7 +187,9 @@ class NAMFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
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 configuration by re-auth."""
if entry := self.hass.config_entries.async_get_entry(self.context["entry_id"]):
self.entry = entry
@ -198,7 +199,7 @@ class NAMFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_reauth_confirm(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Dialog that informs the user that reauth is required."""
errors: dict[str, str] = {}

31
homeassistant/components/nanoleaf/config_flow.py
View File

@ -9,10 +9,9 @@ from typing import Any, Final, cast
from aionanoleaf import InvalidToken, Nanoleaf, Unauthorized, Unavailable
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.components import ssdp, zeroconf
from homeassistant.config_entries import ConfigEntry, ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_HOST, CONF_TOKEN
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers.aiohttp_client import async_get_clientsession
from homeassistant.helpers.json import save_json
from homeassistant.util.json import JsonObjectType, JsonValueType, load_json_object
@ -31,10 +30,10 @@ USER_SCHEMA: Final = vol.Schema(
)
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class NanoleafConfigFlow(ConfigFlow, domain=DOMAIN):
"""Nanoleaf config flow."""
reauth_entry: config_entries.ConfigEntry | None = None
reauth_entry: ConfigEntry | None = None
nanoleaf: Nanoleaf
@ -46,7 +45,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle Nanoleaf flow initiated by the user."""
if user_input is None:
return self.async_show_form(
@ -77,10 +76,12 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
)
return await self.async_step_link()
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 Nanoleaf reauth flow if token is invalid."""
self.reauth_entry = cast(
config_entries.ConfigEntry,
ConfigEntry,
self.hass.config_entries.async_get_entry(self.context["entry_id"]),
)
self.nanoleaf = Nanoleaf(
@ -91,21 +92,21 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_zeroconf(
self, discovery_info: zeroconf.ZeroconfServiceInfo
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle Nanoleaf Zeroconf discovery."""
_LOGGER.debug("Zeroconf discovered: %s", discovery_info)
return await self._async_homekit_zeroconf_discovery_handler(discovery_info)
async def async_step_homekit(
self, discovery_info: zeroconf.ZeroconfServiceInfo
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle Nanoleaf Homekit discovery."""
_LOGGER.debug("Homekit discovered: %s", discovery_info)
return await self._async_homekit_zeroconf_discovery_handler(discovery_info)
async def _async_homekit_zeroconf_discovery_handler(
self, discovery_info: zeroconf.ZeroconfServiceInfo
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle Nanoleaf Homekit and Zeroconf discovery."""
return await self._async_discovery_handler(
discovery_info.host,
@ -113,7 +114,9 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
discovery_info.properties[zeroconf.ATTR_PROPERTIES_ID],
)
async def async_step_ssdp(self, discovery_info: ssdp.SsdpServiceInfo) -> FlowResult:
async def async_step_ssdp(
self, discovery_info: ssdp.SsdpServiceInfo
) -> ConfigFlowResult:
"""Handle Nanoleaf SSDP discovery."""
_LOGGER.debug("SSDP discovered: %s", discovery_info)
return await self._async_discovery_handler(
@ -124,7 +127,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def _async_discovery_handler(
self, host: str, name: str, device_id: str
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle Nanoleaf discovery."""
# The name is unique and printed on the device and cannot be changed.
await self.async_set_unique_id(name)
@ -156,7 +159,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_link(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle Nanoleaf link step."""
if user_input is None:
return self.async_show_form(step_id="link")
@ -188,7 +191,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_setup_finish(
self, discovery_integration_import: bool = False
) -> FlowResult:
) -> ConfigFlowResult:
"""Finish Nanoleaf config flow."""
try:
await self.nanoleaf.get_info()

13
homeassistant/components/neato/config_flow.py
View File

@ -5,8 +5,7 @@ from collections.abc import Mapping
import logging
from typing import Any
from homeassistant.config_entries import SOURCE_REAUTH
from homeassistant.data_entry_flow import FlowResult
from homeassistant.config_entries import SOURCE_REAUTH, ConfigFlowResult
from homeassistant.helpers import config_entry_oauth2_flow
from .const import NEATO_DOMAIN
@ -26,7 +25,7 @@ class OAuth2FlowHandler(
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Create an entry for the flow."""
current_entries = self._async_current_entries()
if self.source != SOURCE_REAUTH and current_entries:
@ -35,19 +34,21 @@ class OAuth2FlowHandler(
return await super().async_step_user(user_input=user_input)
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 migration of old entries."""
return await self.async_step_reauth_confirm()
async def async_step_reauth_confirm(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Confirm reauth upon migration of old entries."""
if user_input is None:
return self.async_show_form(step_id="reauth_confirm")
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. Update an entry if one already exist."""
current_entries = self._async_current_entries()
if self.source == SOURCE_REAUTH and current_entries:

25
homeassistant/components/nest/config_flow.py
View File

@ -22,8 +22,7 @@ from google_nest_sdm.exceptions import (
from google_nest_sdm.structure import InfoTrait, Structure
import voluptuous as vol
from homeassistant.config_entries import SOURCE_REAUTH, ConfigEntry
from homeassistant.data_entry_flow import FlowResult
from homeassistant.config_entries import SOURCE_REAUTH, ConfigEntry, ConfigFlowResult
from homeassistant.helpers import config_entry_oauth2_flow
from homeassistant.util import get_random_string
@ -133,7 +132,7 @@ class NestFlowHandler(
authorize_url = OAUTH2_AUTHORIZE.format(project_id=project_id)
return f"{authorize_url}{query}"
async def async_oauth_create_entry(self, data: dict[str, Any]) -> FlowResult:
async def async_oauth_create_entry(self, data: dict[str, Any]) -> ConfigFlowResult:
"""Complete OAuth setup and finish pubsub or finish."""
_LOGGER.debug("Finishing post-oauth configuration")
self._data.update(data)
@ -142,7 +141,9 @@ class NestFlowHandler(
return await self.async_step_finish()
return await self.async_step_pubsub()
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."""
self._data.update(entry_data)
@ -150,7 +151,7 @@ class NestFlowHandler(
async def async_step_reauth_confirm(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Confirm reauth dialog."""
if user_input is None:
return self.async_show_form(step_id="reauth_confirm")
@ -158,7 +159,7 @@ class NestFlowHandler(
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle a flow initialized by the user."""
self._data[DATA_SDM] = {}
if self.source == SOURCE_REAUTH:
@ -169,7 +170,7 @@ class NestFlowHandler(
async def async_step_create_cloud_project(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle initial step in app credentails flow."""
implementations = await config_entry_oauth2_flow.async_get_implementations(
self.hass, self.DOMAIN
@ -196,7 +197,7 @@ class NestFlowHandler(
async def async_step_cloud_project(
self, user_input: dict | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle cloud project in user input."""
if user_input is not None:
self._data.update(user_input)
@ -216,7 +217,7 @@ class NestFlowHandler(
async def async_step_device_project(
self, user_input: dict | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Collect device access project from user input."""
errors = {}
if user_input is not None:
@ -249,7 +250,7 @@ class NestFlowHandler(
async def async_step_pubsub(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Configure and create Pub/Sub subscriber."""
data = {
**self._data,
@ -313,7 +314,9 @@ class NestFlowHandler(
errors=errors,
)
async def async_step_finish(self, data: dict[str, Any] | None = None) -> FlowResult:
async def async_step_finish(
self, data: dict[str, Any] | None = None
) -> ConfigFlowResult:
"""Create an entry for the SDM flow."""
_LOGGER.debug("Creating/updating configuration entry")
# Update existing config entry when in the reauth flow.

39
homeassistant/components/netatmo/config_flow.py
View File

@ -8,10 +8,14 @@ import uuid
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.config_entries import (
SOURCE_REAUTH,
ConfigEntry,
ConfigFlowResult,
OptionsFlow,
)
from homeassistant.const import CONF_SHOW_ON_MAP, CONF_UUID
from homeassistant.core import callback
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers import config_entry_oauth2_flow, config_validation as cv
from .api import get_api_scopes
@ -40,8 +44,8 @@ class NetatmoFlowHandler(
@staticmethod
@callback
def async_get_options_flow(
config_entry: config_entries.ConfigEntry,
) -> config_entries.OptionsFlow:
config_entry: ConfigEntry,
) -> OptionsFlow:
"""Get the options flow for this handler."""
return NetatmoOptionsFlowHandler(config_entry)
@ -56,32 +60,31 @@ class NetatmoFlowHandler(
scopes = get_api_scopes(self.flow_impl.domain)
return {"scope": " ".join(scopes)}
async def async_step_user(self, user_input: dict | None = None) -> FlowResult:
async def async_step_user(self, user_input: dict | None = None) -> ConfigFlowResult:
"""Handle a flow start."""
await self.async_set_unique_id(DOMAIN)
if (
self.source != config_entries.SOURCE_REAUTH
and self._async_current_entries()
):
if self.source != SOURCE_REAUTH and self._async_current_entries():
return self.async_abort(reason="single_instance_allowed")
return await super().async_step_user(user_input)
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."""
return await self.async_step_reauth_confirm()
async def async_step_reauth_confirm(
self, user_input: dict | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Dialog that informs the user that reauth is required."""
if user_input is None:
return self.async_show_form(step_id="reauth_confirm")
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."""
existing_entry = await self.async_set_unique_id(DOMAIN)
if existing_entry:
@ -92,22 +95,22 @@ class NetatmoFlowHandler(
return await super().async_oauth_create_entry(data)
class NetatmoOptionsFlowHandler(config_entries.OptionsFlow):
class NetatmoOptionsFlowHandler(OptionsFlow):
"""Handle Netatmo options."""
def __init__(self, config_entry: config_entries.ConfigEntry) -> None:
def __init__(self, config_entry: ConfigEntry) -> None:
"""Initialize Netatmo options flow."""
self.config_entry = config_entry
self.options = dict(config_entry.options)
self.options.setdefault(CONF_WEATHER_AREAS, {})
async def async_step_init(self, user_input: dict | None = None) -> FlowResult:
async def async_step_init(self, user_input: dict | None = None) -> ConfigFlowResult:
"""Manage the Netatmo options."""
return await self.async_step_public_weather_areas()
async def async_step_public_weather_areas(
self, user_input: dict | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Manage configuration of Netatmo public weather areas."""
errors: dict = {}
@ -142,7 +145,7 @@ class NetatmoOptionsFlowHandler(config_entries.OptionsFlow):
errors=errors,
)
async def async_step_public_weather(self, user_input: dict) -> FlowResult:
async def async_step_public_weather(self, user_input: dict) -> ConfigFlowResult:
"""Manage configuration of Netatmo public weather sensors."""
if user_input is not None and CONF_NEW_AREA not in user_input:
self.options[CONF_WEATHER_AREAS][
@ -203,7 +206,7 @@ class NetatmoOptionsFlowHandler(config_entries.OptionsFlow):
return self.async_show_form(step_id="public_weather", data_schema=data_schema)
def _create_options_entry(self) -> FlowResult:
def _create_options_entry(self) -> ConfigFlowResult:
"""Update config entry options."""
return self.async_create_entry(
title="Netatmo Public Weather", data=self.options

20
homeassistant/components/netgear/config_flow.py
View File

@ -8,8 +8,13 @@ from urllib.parse import urlparse
from pynetgear import DEFAULT_HOST, DEFAULT_PORT, DEFAULT_USER
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.components import ssdp
from homeassistant.config_entries import (
ConfigEntry,
ConfigFlow,
ConfigFlowResult,
OptionsFlow,
)
from homeassistant.const import (
CONF_HOST,
CONF_PASSWORD,
@ -18,7 +23,6 @@ from homeassistant.const import (
CONF_USERNAME,
)
from homeassistant.core import callback
from homeassistant.data_entry_flow import FlowResult
from homeassistant.util.network import is_ipv4_address
from .const import (
@ -55,10 +59,10 @@ def _ordered_shared_schema(schema_input):
}
class OptionsFlowHandler(config_entries.OptionsFlow):
class OptionsFlowHandler(OptionsFlow):
"""Options for the component."""
def __init__(self, config_entry: config_entries.ConfigEntry) -> None:
def __init__(self, config_entry: ConfigEntry) -> None:
"""Init object."""
self.config_entry = config_entry
@ -81,7 +85,7 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
return self.async_show_form(step_id="init", data_schema=settings_schema)
class NetgearFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
class NetgearFlowHandler(ConfigFlow, domain=DOMAIN):
"""Handle a config flow."""
VERSION = 1
@ -99,7 +103,7 @@ class NetgearFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
@staticmethod
@callback
def async_get_options_flow(
config_entry: config_entries.ConfigEntry,
config_entry: ConfigEntry,
) -> OptionsFlowHandler:
"""Get the options flow."""
return OptionsFlowHandler(config_entry)
@ -121,7 +125,9 @@ class NetgearFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
description_placeholders=self.placeholders,
)
async def async_step_ssdp(self, discovery_info: ssdp.SsdpServiceInfo) -> FlowResult:
async def async_step_ssdp(
self, discovery_info: ssdp.SsdpServiceInfo
) -> ConfigFlowResult:
"""Initialize flow from ssdp."""
updated_data: dict[str, str | int | bool] = {}

12
homeassistant/components/netgear_lte/config_flow.py
View File

@ -8,18 +8,18 @@ from eternalegypt import Error, Modem
from eternalegypt.eternalegypt import Information
import voluptuous as vol
from homeassistant import config_entries, exceptions
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_HOST, CONF_PASSWORD
from homeassistant.data_entry_flow import FlowResult
from homeassistant.exceptions import HomeAssistantError
from homeassistant.helpers.aiohttp_client import async_create_clientsession
from .const import DEFAULT_HOST, DOMAIN, LOGGER, MANUFACTURER
class NetgearLTEFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
class NetgearLTEFlowHandler(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Netgear LTE."""
async def async_step_import(self, config: dict[str, Any]) -> FlowResult:
async def async_step_import(self, config: dict[str, Any]) -> ConfigFlowResult:
"""Import a configuration from config.yaml."""
host = config[CONF_HOST]
password = config[CONF_PASSWORD]
@ -37,7 +37,7 @@ class NetgearLTEFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle a flow initiated by the user."""
errors = {}
@ -94,7 +94,7 @@ class NetgearLTEFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
return info
class InputValidationError(exceptions.HomeAssistantError):
class InputValidationError(HomeAssistantError):
"""Error to indicate we cannot proceed due to invalid input."""
def __init__(self, base: str) -> None:

12
homeassistant/components/nexia/config_flow.py
View File

@ -6,8 +6,10 @@ from nexia.const import BRAND_ASAIR, BRAND_NEXIA, BRAND_TRANE
from nexia.home import NexiaHome
import voluptuous as vol
from homeassistant import config_entries, core, exceptions
from homeassistant.config_entries import ConfigFlow
from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
from homeassistant.core import HomeAssistant
from homeassistant.exceptions import HomeAssistantError
from homeassistant.helpers.aiohttp_client import async_get_clientsession
from .const import (
@ -36,7 +38,7 @@ DATA_SCHEMA = vol.Schema(
)
async def validate_input(hass: core.HomeAssistant, data):
async def validate_input(hass: HomeAssistant, data):
"""Validate the user input allows us to connect.
Data has the keys from DATA_SCHEMA with values provided by the user.
@ -73,7 +75,7 @@ async def validate_input(hass: core.HomeAssistant, data):
return info
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class NexiaConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Nexia."""
VERSION = 1
@ -102,9 +104,9 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
)
class CannotConnect(exceptions.HomeAssistantError):
class CannotConnect(HomeAssistantError):
"""Error to indicate we cannot connect."""
class InvalidAuth(exceptions.HomeAssistantError):
class InvalidAuth(HomeAssistantError):
"""Error to indicate there is invalid auth."""

15
homeassistant/components/nextbus/config_flow.py
View File

@ -5,9 +5,8 @@ import logging
from py_nextbus import NextBusClient
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_NAME, CONF_STOP
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers.selector import (
SelectOptionDict,
SelectSelector,
@ -89,7 +88,7 @@ def _unique_id_from_data(data: dict[str, str]) -> str:
return f"{data[CONF_AGENCY]}_{data[CONF_ROUTE]}_{data[CONF_STOP]}"
class NextBusFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
class NextBusFlowHandler(ConfigFlow, domain=DOMAIN):
"""Handle Nextbus configuration."""
VERSION = 1
@ -104,7 +103,7 @@ class NextBusFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
self._client = NextBusClient(output_format="json")
_LOGGER.info("Init new config flow")
async def async_step_import(self, config_input: dict[str, str]) -> FlowResult:
async def async_step_import(self, config_input: dict[str, str]) -> ConfigFlowResult:
"""Handle import of config."""
agency_tag = config_input[CONF_AGENCY]
route_tag = config_input[CONF_ROUTE]
@ -141,14 +140,14 @@ class NextBusFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user(
self,
user_input: dict[str, str] | None = None,
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle a flow initiated by the user."""
return await self.async_step_agency(user_input)
async def async_step_agency(
self,
user_input: dict[str, str] | None = None,
) -> FlowResult:
) -> ConfigFlowResult:
"""Select agency."""
if user_input is not None:
self.data[CONF_AGENCY] = user_input[CONF_AGENCY]
@ -173,7 +172,7 @@ class NextBusFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_route(
self,
user_input: dict[str, str] | None = None,
) -> FlowResult:
) -> ConfigFlowResult:
"""Select route."""
if user_input is not None:
self.data[CONF_ROUTE] = user_input[CONF_ROUTE]
@ -198,7 +197,7 @@ class NextBusFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_stop(
self,
user_input: dict[str, str] | None = None,
) -> FlowResult:
) -> ConfigFlowResult:
"""Select stop."""
if user_input is not None:

11
homeassistant/components/nextcloud/config_flow.py
View File

@ -12,9 +12,8 @@ from nextcloudmonitor import (
)
import voluptuous as vol
from homeassistant.config_entries import ConfigEntry, ConfigFlow
from homeassistant.config_entries import ConfigEntry, ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_PASSWORD, CONF_URL, CONF_USERNAME, CONF_VERIFY_SSL
from homeassistant.data_entry_flow import FlowResult
from .const import DEFAULT_VERIFY_SSL, DOMAIN
@ -52,7 +51,7 @@ class NextcloudConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle a flow initialized by the user."""
errors = {}
@ -75,14 +74,16 @@ class NextcloudConfigFlow(ConfigFlow, domain=DOMAIN):
step_id="user", data_schema=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:
"""Handle flow upon an API authentication error."""
self._entry = self.hass.config_entries.async_get_entry(self.context["entry_id"])
return await self.async_step_reauth_confirm()
async def async_step_reauth_confirm(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle reauthorization flow."""
errors = {}
assert self._entry is not None

9
homeassistant/components/nextdns/config_flow.py
View File

@ -8,15 +8,14 @@ from aiohttp.client_exceptions import ClientConnectorError
from nextdns import ApiError, InvalidApiKeyError, NextDns
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_API_KEY, CONF_PROFILE_NAME
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers.aiohttp_client import async_get_clientsession
from .const import CONF_PROFILE_ID, DOMAIN
class NextDnsFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
class NextDnsFlowHandler(ConfigFlow, domain=DOMAIN):
"""Config flow for NextDNS."""
VERSION = 1
@ -28,7 +27,7 @@ class NextDnsFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle a flow initialized by the user."""
errors: dict[str, str] = {}
@ -58,7 +57,7 @@ class NextDnsFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_profiles(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the profiles step."""
errors: dict[str, str] = {}

7
homeassistant/components/nfandroidtv/config_flow.py
View File

@ -7,21 +7,20 @@ from typing import Any
from notifications_android_tv.notifications import ConnectError, Notifications
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.data_entry_flow import FlowResult
from .const import DEFAULT_NAME, DOMAIN
_LOGGER = logging.getLogger(__name__)
class NFAndroidTVFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
class NFAndroidTVFlowHandler(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for NFAndroidTV."""
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle a flow initiated by the user."""
errors = {}

11
homeassistant/components/nibe_heatpump/config_flow.py
View File

@ -17,10 +17,9 @@ from nibe.heatpump import HeatPump, Model
import voluptuous as vol
import yarl
from homeassistant import config_entries
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_IP_ADDRESS, CONF_MODEL
from homeassistant.core import HomeAssistant
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers import selector
from .const import (
@ -166,20 +165,20 @@ async def validate_modbus_input(
}
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class NibeHeatPumpConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Nibe Heat Pump."""
VERSION = 1
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the initial step."""
return self.async_show_menu(step_id="user", menu_options=["modbus", "nibegw"])
async def async_step_modbus(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the modbus step."""
if user_input is None:
return self.async_show_form(
@ -205,7 +204,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_nibegw(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the nibegw step."""
if user_input is None:
return self.async_show_form(

10
homeassistant/components/nightscout/config_flow.py
View File

@ -6,9 +6,9 @@ from aiohttp import ClientError, ClientResponseError
from py_nightscout import Api as NightscoutAPI
import voluptuous as vol
from homeassistant import config_entries, exceptions
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_API_KEY, CONF_URL
from homeassistant.data_entry_flow import FlowResult
from homeassistant.exceptions import HomeAssistantError
from .const import DOMAIN
from .utils import hash_from_url
@ -36,14 +36,14 @@ async def _validate_input(data: dict[str, Any]) -> dict[str, str]:
return {"title": status.name}
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class NightscoutConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Nightscout."""
VERSION = 1
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the initial step."""
errors: dict[str, str] = {}
@ -66,7 +66,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
)
class InputValidationError(exceptions.HomeAssistantError):
class InputValidationError(HomeAssistantError):
"""Error to indicate we cannot proceed due to invalid input."""
def __init__(self, base: str) -> None:

20
homeassistant/components/nina/config_flow.py
View File

@ -6,9 +6,13 @@ from typing import Any
from pynina import ApiError, Nina
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.data_entry_flow import FlowResult
from homeassistant.helpers.aiohttp_client import async_get_clientsession
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.entity_registry import (
@ -81,7 +85,7 @@ def prepare_user_input(
return user_input
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class NinaConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for NINA."""
VERSION: int = 1
@ -96,9 +100,9 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
self.regions[name] = {}
async def async_step_user(
self: ConfigFlow,
self,
user_input: dict[str, Any] | None = None,
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the initial step."""
errors: dict[str, Any] = {}
@ -158,16 +162,16 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
@staticmethod
@callback
def async_get_options_flow(
config_entry: config_entries.ConfigEntry,
config_entry: ConfigEntry,
) -> OptionsFlowHandler:
"""Get the options flow for this handler."""
return OptionsFlowHandler(config_entry)
class OptionsFlowHandler(config_entries.OptionsFlow):
class OptionsFlowHandler(OptionsFlow):
"""Handle a option flow for nut."""
def __init__(self, config_entry: config_entries.ConfigEntry) -> None:
def __init__(self, config_entry: ConfigEntry) -> None:
"""Initialize options flow."""
self.config_entry = config_entry
self.data = dict(self.config_entry.data)

19
homeassistant/components/nmap_tracker/config_flow.py
View File

@ -6,7 +6,6 @@ from typing import Any
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.components import network
from homeassistant.components.device_tracker import (
CONF_CONSIDER_HOME,
@ -14,10 +13,14 @@ from homeassistant.components.device_tracker import (
DEFAULT_CONSIDER_HOME,
)
from homeassistant.components.network import MDNS_TARGET_IP
from homeassistant.config_entries import ConfigEntry, OptionsFlow
from homeassistant.config_entries import (
ConfigEntry,
ConfigFlow,
ConfigFlowResult,
OptionsFlow,
)
from homeassistant.const import CONF_EXCLUDE, CONF_HOSTS
from homeassistant.core import HomeAssistant, callback
from homeassistant.data_entry_flow import FlowResult
import homeassistant.helpers.config_validation as cv
from .const import (
@ -133,16 +136,16 @@ async def _async_build_schema_with_user_input(
return vol.Schema(schema)
class OptionsFlowHandler(config_entries.OptionsFlow):
class OptionsFlowHandler(OptionsFlow):
"""Handle a option flow for homekit."""
def __init__(self, config_entry: config_entries.ConfigEntry) -> None:
def __init__(self, config_entry: ConfigEntry) -> None:
"""Initialize options flow."""
self.options = dict(config_entry.options)
async def async_step_init(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle options flow."""
errors = {}
if user_input is not None:
@ -163,7 +166,7 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
)
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class NmapTrackerConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Nmap Tracker."""
VERSION = 1
@ -174,7 +177,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the initial step."""
errors = {}
if user_input is not None:

28
homeassistant/components/nobo_hub/config_flow.py
View File

@ -7,10 +7,14 @@ from typing import Any
from pynobo import nobo
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.config_entries import (
ConfigEntry,
ConfigFlow,
ConfigFlowResult,
OptionsFlow,
)
from homeassistant.const import CONF_IP_ADDRESS
from homeassistant.core import callback
from homeassistant.data_entry_flow import FlowResult
from homeassistant.exceptions import HomeAssistantError
from .const import (
@ -26,7 +30,7 @@ DATA_NOBO_HUB_IMPL = "nobo_hub_flow_implementation"
DEVICE_INPUT = "device_input"
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class NoboHubConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Nobø Ecohub."""
VERSION = 1
@ -38,7 +42,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the initial step."""
if self._discovered_hubs is None:
self._discovered_hubs = dict(await nobo.async_discover_hubs())
@ -67,7 +71,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_selected(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle configuration of a selected discovered device."""
errors = {}
if user_input is not None:
@ -97,7 +101,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_manual(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle configuration of an undiscovered device."""
errors = {}
if user_input is not None:
@ -124,7 +128,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def _create_configuration(
self, serial: str, ip_address: str, auto_discovered: bool
) -> FlowResult:
) -> ConfigFlowResult:
await self.async_set_unique_id(serial)
self._abort_if_unique_id_configured()
name = await self._test_connection(serial, ip_address)
@ -164,8 +168,8 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
@staticmethod
@callback
def async_get_options_flow(
config_entry: config_entries.ConfigEntry,
) -> config_entries.OptionsFlow:
config_entry: ConfigEntry,
) -> OptionsFlow:
"""Get the options flow for this handler."""
return OptionsFlowHandler(config_entry)
@ -179,14 +183,14 @@ class NoboHubConnectError(HomeAssistantError):
self.msg = msg
class OptionsFlowHandler(config_entries.OptionsFlow):
class OptionsFlowHandler(OptionsFlow):
"""Handles options flow for the component."""
def __init__(self, config_entry: config_entries.ConfigEntry) -> None:
def __init__(self, config_entry: ConfigEntry) -> None:
"""Initialize the options flow."""
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:
"""Manage the options."""
if user_input is not None:

14
homeassistant/components/notion/config_flow.py
View File

@ -8,11 +8,9 @@ from typing import Any
from aionotion.errors import InvalidCredentialsError, NotionError
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.config_entries import ConfigEntry
from homeassistant.config_entries import ConfigEntry, ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
from homeassistant.core import HomeAssistant
from homeassistant.data_entry_flow import FlowResult
from .const import CONF_REFRESH_TOKEN, CONF_USER_UUID, DOMAIN, LOGGER
from .util import async_get_client_with_credentials
@ -64,7 +62,7 @@ async def async_validate_credentials(
)
class NotionFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
class NotionFlowHandler(ConfigFlow, domain=DOMAIN):
"""Handle a Notion config flow."""
VERSION = 1
@ -73,7 +71,9 @@ class NotionFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
"""Initialize."""
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:
"""Handle configuration by re-auth."""
self._reauth_entry = self.hass.config_entries.async_get_entry(
self.context["entry_id"]
@ -82,7 +82,7 @@ class NotionFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_reauth_confirm(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle re-auth completion."""
assert self._reauth_entry
@ -121,7 +121,7 @@ class NotionFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, str] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the start of the config flow."""
if not user_input:
return self.async_show_form(step_id="user", data_schema=AUTH_SCHEMA)

14
homeassistant/components/nuheat/config_flow.py
View File

@ -6,8 +6,10 @@ import nuheat
import requests.exceptions
import voluptuous as vol
from homeassistant import config_entries, core, exceptions
from homeassistant.config_entries import ConfigFlow
from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
from homeassistant.core import HomeAssistant
from homeassistant.exceptions import HomeAssistantError
from .const import CONF_SERIAL_NUMBER, DOMAIN
@ -22,7 +24,7 @@ DATA_SCHEMA = vol.Schema(
)
async def validate_input(hass: core.HomeAssistant, data):
async def validate_input(hass: HomeAssistant, data):
"""Validate the user input allows us to connect.
Data has the keys from DATA_SCHEMA with values provided by the user.
@ -56,7 +58,7 @@ async def validate_input(hass: core.HomeAssistant, data):
return {"title": thermostat.room, "serial_number": thermostat.serial_number}
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class NuHeatConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for NuHeat."""
VERSION = 1
@ -87,13 +89,13 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
)
class CannotConnect(exceptions.HomeAssistantError):
class CannotConnect(HomeAssistantError):
"""Error to indicate we cannot connect."""
class InvalidAuth(exceptions.HomeAssistantError):
class InvalidAuth(HomeAssistantError):
"""Error to indicate there is invalid auth."""
class InvalidThermostat(exceptions.HomeAssistantError):
class InvalidThermostat(HomeAssistantError):
"""Error to indicate there is invalid thermostat."""

13
homeassistant/components/nuki/config_flow.py
View File

@ -8,10 +8,9 @@ from pynuki.bridge import InvalidCredentialsException
from requests.exceptions import RequestException
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.components import dhcp
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_HOST, CONF_PORT, CONF_TOKEN
from homeassistant.data_entry_flow import FlowResult
from .const import CONF_ENCRYPT_TOKEN, DEFAULT_PORT, DEFAULT_TIMEOUT, DOMAIN
from .helpers import CannotConnect, InvalidAuth, parse_id
@ -59,7 +58,7 @@ async def validate_input(hass, data):
return info
class NukiConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class NukiConfigFlow(ConfigFlow, domain=DOMAIN):
"""Nuki config flow."""
def __init__(self):
@ -71,7 +70,9 @@ class NukiConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
"""Handle a flow initiated by the user."""
return await self.async_step_validate(user_input)
async def async_step_dhcp(self, discovery_info: dhcp.DhcpServiceInfo) -> FlowResult:
async def async_step_dhcp(
self, discovery_info: dhcp.DhcpServiceInfo
) -> ConfigFlowResult:
"""Prepare configuration for a DHCP discovered Nuki bridge."""
await self.async_set_unique_id(discovery_info.hostname[12:].upper())
@ -87,7 +88,9 @@ class NukiConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
return await self.async_step_validate()
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."""
self._data = entry_data

20
homeassistant/components/nut/config_flow.py
View File

@ -7,9 +7,13 @@ from typing import Any
import voluptuous as vol
from homeassistant import exceptions
from homeassistant.components import zeroconf
from homeassistant.config_entries import ConfigEntry, ConfigFlow, OptionsFlow
from homeassistant.config_entries import (
ConfigEntry,
ConfigFlow,
ConfigFlowResult,
OptionsFlow,
)
from homeassistant.const import (
CONF_ALIAS,
CONF_BASE,
@ -20,7 +24,7 @@ from homeassistant.const import (
CONF_USERNAME,
)
from homeassistant.core import HomeAssistant, callback
from homeassistant.data_entry_flow import FlowResult
from homeassistant.exceptions import HomeAssistantError
from . import PyNUTData
from .const import DEFAULT_HOST, DEFAULT_PORT, DEFAULT_SCAN_INTERVAL, DOMAIN
@ -94,7 +98,7 @@ class NutConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_zeroconf(
self, discovery_info: zeroconf.ZeroconfServiceInfo
) -> FlowResult:
) -> ConfigFlowResult:
"""Prepare configuration for a discovered nut device."""
self.discovery_info = discovery_info
await self._async_handle_discovery_without_unique_id()
@ -106,7 +110,7 @@ class NutConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the user input."""
errors: dict[str, str] = {}
if user_input is not None:
@ -136,7 +140,7 @@ class NutConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_ups(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the picking the ups."""
errors: dict[str, str] = {}
@ -194,7 +198,7 @@ class OptionsFlowHandler(OptionsFlow):
async def async_step_init(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle options flow."""
if user_input is not None:
return self.async_create_entry(title="", data=user_input)
@ -212,5 +216,5 @@ class OptionsFlowHandler(OptionsFlow):
return self.async_show_form(step_id="init", data_schema=vol.Schema(base_schema))
class CannotConnect(exceptions.HomeAssistantError):
class CannotConnect(HomeAssistantError):
"""Error to indicate we cannot connect."""

15
homeassistant/components/nws/config_flow.py
View File

@ -8,9 +8,10 @@ import aiohttp
from pynws import SimpleNWS
import voluptuous as vol
from homeassistant import config_entries, core, exceptions
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_API_KEY, CONF_LATITUDE, CONF_LONGITUDE
from homeassistant.data_entry_flow import FlowResult
from homeassistant.core import HomeAssistant
from homeassistant.exceptions import HomeAssistantError
from homeassistant.helpers import config_validation as cv
from homeassistant.helpers.aiohttp_client import async_get_clientsession
@ -20,9 +21,7 @@ from .const import CONF_STATION, DOMAIN
_LOGGER = logging.getLogger(__name__)
async def validate_input(
hass: core.HomeAssistant, data: dict[str, Any]
) -> dict[str, str]:
async def validate_input(hass: HomeAssistant, data: dict[str, Any]) -> dict[str, str]:
"""Validate the user input allows us to connect.
Data has the keys from DATA_SCHEMA with values provided by the user.
@ -45,14 +44,14 @@ async def validate_input(
return {"title": nws.station}
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class NWSConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for National Weather Service (NWS)."""
VERSION = 1
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the initial step."""
errors: dict[str, str] = {}
if user_input is not None:
@ -88,5 +87,5 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
)
class CannotConnect(exceptions.HomeAssistantError):
class CannotConnect(HomeAssistantError):
"""Error to indicate we cannot connect."""

5
homeassistant/components/nzbget/config_flow.py
View File

@ -6,7 +6,7 @@ from typing import Any
import voluptuous as vol
from homeassistant.config_entries import ConfigFlow
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import (
CONF_HOST,
CONF_NAME,
@ -16,7 +16,6 @@ from homeassistant.const import (
CONF_USERNAME,
CONF_VERIFY_SSL,
)
from homeassistant.data_entry_flow import FlowResult
from .const import DEFAULT_NAME, DEFAULT_PORT, DEFAULT_SSL, DEFAULT_VERIFY_SSL, DOMAIN
from .coordinator import NZBGetAPI, NZBGetAPIException
@ -48,7 +47,7 @@ class NZBGetConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle a flow initiated by the user."""
if self._async_current_entries():
return self.async_abort(reason="single_instance_allowed")

11
homeassistant/components/obihai/config_flow.py
View File

@ -9,10 +9,9 @@ from pyobihai import PyObihai
import voluptuous as vol
from homeassistant.components import dhcp
from homeassistant.config_entries import ConfigFlow
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
from homeassistant.core import HomeAssistant
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers.device_registry import format_mac
from .connectivity import validate_auth
@ -59,7 +58,7 @@ class ObihaiFlowHandler(ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle a flow initialized by the user."""
errors: dict[str, str] = {}
@ -94,7 +93,9 @@ class ObihaiFlowHandler(ConfigFlow, domain=DOMAIN):
data_schema=self.add_suggested_values_to_schema(data_schema, user_input),
)
async def async_step_dhcp(self, discovery_info: dhcp.DhcpServiceInfo) -> FlowResult:
async def async_step_dhcp(
self, discovery_info: dhcp.DhcpServiceInfo
) -> ConfigFlowResult:
"""Prepare configuration for a DHCP discovered Obihai."""
self._dhcp_discovery_info = discovery_info
@ -102,7 +103,7 @@ class ObihaiFlowHandler(ConfigFlow, domain=DOMAIN):
async def async_step_dhcp_confirm(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Attempt to confirm."""
assert self._dhcp_discovery_info
await self.async_set_unique_id(format_mac(self._dhcp_discovery_info.macaddress))

19
homeassistant/components/octoprint/config_flow.py
View File

@ -11,8 +11,8 @@ from pyoctoprintapi import ApiError, OctoprintClient, OctoprintException
import voluptuous as vol
from yarl import URL
from homeassistant import config_entries, data_entry_flow, exceptions
from homeassistant.components import ssdp, zeroconf
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import (
CONF_API_KEY,
CONF_HOST,
@ -22,7 +22,8 @@ from homeassistant.const import (
CONF_USERNAME,
CONF_VERIFY_SSL,
)
from homeassistant.data_entry_flow import FlowResult
from homeassistant.data_entry_flow import AbortFlow
from homeassistant.exceptions import HomeAssistantError
import homeassistant.helpers.config_validation as cv
from homeassistant.util.ssl import get_default_context, get_default_no_verify_context
@ -47,7 +48,7 @@ def _schema_with_defaults(
)
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class OctoPrintConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for OctoPrint."""
VERSION = 1
@ -76,7 +77,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
errors = {}
try:
return await self._finish_config(user_input)
except data_entry_flow.AbortFlow as err:
except AbortFlow as err:
raise err from None
except CannotConnect:
errors["base"] = "cannot_connect"
@ -160,7 +161,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_zeroconf(
self, discovery_info: zeroconf.ZeroconfServiceInfo
) -> data_entry_flow.FlowResult:
) -> ConfigFlowResult:
"""Handle discovery flow."""
uuid = discovery_info.properties["uuid"]
await self.async_set_unique_id(uuid)
@ -186,7 +187,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_ssdp(
self, discovery_info: ssdp.SsdpServiceInfo
) -> data_entry_flow.FlowResult:
) -> ConfigFlowResult:
"""Handle ssdp discovery flow."""
uuid = discovery_info.upnp["UDN"][5:]
await self.async_set_unique_id(uuid)
@ -209,7 +210,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
return await self.async_step_user()
async def async_step_reauth(self, config: Mapping[str, Any]) -> FlowResult:
async def async_step_reauth(self, config: Mapping[str, Any]) -> ConfigFlowResult:
"""Handle reauthorization request from Octoprint."""
self._reauth_data = dict(config)
@ -223,7 +224,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_reauth_confirm(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle reauthorization flow."""
assert self._reauth_data is not None
@ -279,5 +280,5 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
session.detach()
class CannotConnect(exceptions.HomeAssistantError):
class CannotConnect(HomeAssistantError):
"""Error to indicate we cannot connect."""

10
homeassistant/components/omnilogic/config_flow.py
View File

@ -6,7 +6,7 @@ import logging
from omnilogic import LoginException, OmniLogic, OmniLogicException
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.config_entries import ConfigEntry, ConfigFlow, OptionsFlow
from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
from homeassistant.core import callback
from homeassistant.helpers import aiohttp_client
@ -16,7 +16,7 @@ from .const import CONF_SCAN_INTERVAL, DEFAULT_PH_OFFSET, DEFAULT_SCAN_INTERVAL,
_LOGGER = logging.getLogger(__name__)
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class OmniLogicConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Omnilogic."""
VERSION = 1
@ -24,7 +24,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
@staticmethod
@callback
def async_get_options_flow(
config_entry: config_entries.ConfigEntry,
config_entry: ConfigEntry,
) -> OptionsFlowHandler:
"""Get the options flow for this handler."""
return OptionsFlowHandler(config_entry)
@ -72,10 +72,10 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
)
class OptionsFlowHandler(config_entries.OptionsFlow):
class OptionsFlowHandler(OptionsFlow):
"""Handle Omnilogic client options."""
def __init__(self, config_entry: config_entries.ConfigEntry) -> None:
def __init__(self, config_entry: ConfigEntry) -> None:
"""Initialize options flow."""
self.config_entry = config_entry

7
homeassistant/components/oncue/config_flow.py
View File

@ -7,9 +7,8 @@ from typing import Any
from aiooncue import LoginFailedException, Oncue
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers.aiohttp_client import async_get_clientsession
from .const import CONNECTION_EXCEPTIONS, DOMAIN
@ -17,14 +16,14 @@ from .const import CONNECTION_EXCEPTIONS, DOMAIN
_LOGGER = logging.getLogger(__name__)
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class OncueConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Oncue."""
VERSION = 1
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the initial step."""
errors = {}

10
homeassistant/components/onewire/config_flow.py
View File

@ -8,11 +8,11 @@ import voluptuous as vol
from homeassistant.config_entries import (
ConfigEntry,
ConfigFlow,
ConfigFlowResult,
OptionsFlowWithConfigEntry,
)
from homeassistant.const import CONF_HOST, CONF_PORT
from homeassistant.core import HomeAssistant, callback
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers import config_validation as cv, device_registry as dr
from homeassistant.helpers.device_registry import DeviceEntry
@ -65,7 +65,7 @@ class OneWireFlowHandler(ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle 1-Wire config flow start.
Let user manually input configuration.
@ -124,7 +124,7 @@ class OnewireOptionsFlowHandler(OptionsFlowWithConfigEntry):
async def async_step_init(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Manage the options."""
device_registry = dr.async_get(self.hass)
self.configurable_devices = {
@ -142,7 +142,7 @@ class OnewireOptionsFlowHandler(OptionsFlowWithConfigEntry):
async def async_step_device_selection(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Select what devices to configure."""
errors = {}
if user_input is not None:
@ -187,7 +187,7 @@ class OnewireOptionsFlowHandler(OptionsFlowWithConfigEntry):
async def async_step_configure_device(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Config precision option for device."""
if user_input is not None:
self._update_device_options(user_input)

34
homeassistant/components/onvif/config_flow.py
View File

@ -14,7 +14,6 @@ from wsdiscovery.scope import Scope
from wsdiscovery.service import Service
from zeep.exceptions import Fault
from homeassistant import config_entries
from homeassistant.components import dhcp
from homeassistant.components.ffmpeg import CONF_EXTRA_ARGUMENTS
from homeassistant.components.stream import (
@ -22,6 +21,13 @@ from homeassistant.components.stream import (
CONF_USE_WALLCLOCK_AS_TIMESTAMPS,
RTSP_TRANSPORTS,
)
from homeassistant.config_entries import (
ConfigEntry,
ConfigEntryState,
ConfigFlow,
ConfigFlowResult,
OptionsFlow,
)
from homeassistant.const import (
CONF_HOST,
CONF_NAME,
@ -30,7 +36,7 @@ from homeassistant.const import (
CONF_USERNAME,
)
from homeassistant.core import HomeAssistant, callback
from homeassistant.data_entry_flow import AbortFlow, FlowResult
from homeassistant.data_entry_flow import AbortFlow
from homeassistant.helpers import device_registry as dr
from .const import (
@ -91,16 +97,16 @@ async def async_discovery(hass: HomeAssistant) -> list[dict[str, Any]]:
return devices
class OnvifFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
class OnvifFlowHandler(ConfigFlow, domain=DOMAIN):
"""Handle a ONVIF config flow."""
VERSION = 1
_reauth_entry: config_entries.ConfigEntry
_reauth_entry: ConfigEntry
@staticmethod
@callback
def async_get_options_flow(
config_entry: config_entries.ConfigEntry,
config_entry: ConfigEntry,
) -> OnvifOptionsFlowHandler:
"""Get the options flow for this handler."""
return OnvifOptionsFlowHandler(config_entry)
@ -123,7 +129,9 @@ class OnvifFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
data_schema=vol.Schema({vol.Required("auto", default=True): bool}),
)
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 of an existing config entry."""
reauth_entry = self.hass.config_entries.async_get_entry(
self.context["entry_id"]
@ -134,7 +142,7 @@ class OnvifFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_reauth_confirm(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Confirm reauth."""
entry = self._reauth_entry
errors: dict[str, str] | None = {}
@ -161,7 +169,9 @@ class OnvifFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
description_placeholders=description_placeholders,
)
async def async_step_dhcp(self, discovery_info: dhcp.DhcpServiceInfo) -> FlowResult:
async def async_step_dhcp(
self, discovery_info: dhcp.DhcpServiceInfo
) -> ConfigFlowResult:
"""Handle dhcp discovery."""
hass = self.hass
mac = discovery_info.macaddress
@ -176,7 +186,7 @@ class OnvifFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
if (
not (entry := hass.config_entries.async_get_entry(entry_id))
or entry.domain != DOMAIN
or entry.state is config_entries.ConfigEntryState.LOADED
or entry.state is ConfigEntryState.LOADED
):
continue
if hass.config_entries.async_update_entry(
@ -235,7 +245,7 @@ class OnvifFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_configure(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Device configuration."""
errors: dict[str, str] = {}
description_placeholders: dict[str, str] = {}
@ -374,10 +384,10 @@ class OnvifFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
await device.close()
class OnvifOptionsFlowHandler(config_entries.OptionsFlow):
class OnvifOptionsFlowHandler(OptionsFlow):
"""Handle ONVIF options."""
def __init__(self, config_entry: config_entries.ConfigEntry) -> None:
def __init__(self, config_entry: ConfigEntry) -> None:
"""Initialize ONVIF options flow."""
self.config_entry = config_entry
self.options = dict(config_entry.options)

5
homeassistant/components/open_meteo/config_flow.py
View File

@ -6,9 +6,8 @@ from typing import Any
import voluptuous as vol
from homeassistant.components.zone import DOMAIN as ZONE_DOMAIN
from homeassistant.config_entries import ConfigFlow
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_ZONE
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers.selector import EntitySelector, EntitySelectorConfig
from .const import DOMAIN
@ -21,7 +20,7 @@ class OpenMeteoFlowHandler(ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle a flow initialized by the user."""
if user_input is not None:
await self.async_set_unique_id(user_input[CONF_ZONE])

24
homeassistant/components/openai_conversation/config_flow.py
View File

@ -9,10 +9,14 @@ from typing import Any
import openai
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.config_entries import (
ConfigEntry,
ConfigFlow,
ConfigFlowResult,
OptionsFlow,
)
from homeassistant.const import CONF_API_KEY
from homeassistant.core import HomeAssistant
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers.selector import (
NumberSelector,
NumberSelectorConfig,
@ -61,14 +65,14 @@ async def validate_input(hass: HomeAssistant, data: dict[str, Any]) -> None:
await hass.async_add_executor_job(client.with_options(timeout=10.0).models.list)
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class OpenAIConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for OpenAI Conversation."""
VERSION = 1
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the initial step."""
if user_input is None:
return self.async_show_form(
@ -95,22 +99,22 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
@staticmethod
def async_get_options_flow(
config_entry: config_entries.ConfigEntry,
) -> config_entries.OptionsFlow:
config_entry: ConfigEntry,
) -> OptionsFlow:
"""Create the options flow."""
return OptionsFlow(config_entry)
return OpenAIOptionsFlow(config_entry)
class OptionsFlow(config_entries.OptionsFlow):
class OpenAIOptionsFlow(OptionsFlow):
"""OpenAI config flow options handler."""
def __init__(self, config_entry: config_entries.ConfigEntry) -> None:
def __init__(self, config_entry: ConfigEntry) -> None:
"""Initialize options flow."""
self.config_entry = config_entry
async def async_step_init(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Manage the options."""
if user_input is not None:
return self.async_create_entry(title="OpenAI Conversation", data=user_input)

14
homeassistant/components/openexchangerates/config_flow.py
View File

@ -12,10 +12,10 @@ from aioopenexchangerates import (
)
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.config_entries import ConfigEntry, ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_API_KEY, CONF_BASE
from homeassistant.core import HomeAssistant
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 .const import CLIENT_TIMEOUT, DEFAULT_BASE, DOMAIN, LOGGER
@ -45,7 +45,7 @@ async def validate_input(hass: HomeAssistant, data: dict[str, str]) -> dict[str,
return {"title": data[CONF_BASE]}
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class OpenExchangeRatesConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Open Exchange Rates."""
VERSION = 1
@ -53,11 +53,11 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
def __init__(self) -> None:
"""Initialize the config flow."""
self.currencies: dict[str, str] = {}
self._reauth_entry: config_entries.ConfigEntry | None = None
self._reauth_entry: ConfigEntry | None = None
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the initial step."""
currencies = await self.async_get_currencies()
@ -110,7 +110,9 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
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."""
self._reauth_entry = self.hass.config_entries.async_get_entry(
self.context["entry_id"]

7
homeassistant/components/opengarage/config_flow.py
View File

@ -8,10 +8,9 @@ import aiohttp
import opengarage
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_HOST, CONF_PORT, CONF_VERIFY_SSL
from homeassistant.core import HomeAssistant
from homeassistant.data_entry_flow import FlowResult
from homeassistant.exceptions import HomeAssistantError
from homeassistant.helpers.aiohttp_client import async_get_clientsession
from homeassistant.helpers.device_registry import format_mac
@ -53,14 +52,14 @@ async def validate_input(hass: HomeAssistant, data: dict[str, Any]) -> dict[str,
return {"title": status.get("name"), "unique_id": format_mac(status["mac"])}
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class OpenGarageConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for OpenGarage."""
VERSION = 1
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the initial step."""
if user_input is None:
return self.async_show_form(

9
homeassistant/components/openhome/config_flow.py
View File

@ -8,9 +8,8 @@ from homeassistant.components.ssdp import (
ATTR_UPNP_UDN,
SsdpServiceInfo,
)
from homeassistant.config_entries import ConfigFlow
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_HOST, CONF_NAME
from homeassistant.data_entry_flow import FlowResult
from .const import DOMAIN
@ -25,7 +24,9 @@ def _is_complete_discovery(discovery_info: SsdpServiceInfo) -> bool:
class OpenhomeConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle an Openhome config flow."""
async def async_step_ssdp(self, discovery_info: SsdpServiceInfo) -> FlowResult:
async def async_step_ssdp(
self, discovery_info: SsdpServiceInfo
) -> ConfigFlowResult:
"""Handle a flow initialized by discovery."""
_LOGGER.debug("async_step_ssdp: started")
@ -51,7 +52,7 @@ class OpenhomeConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_confirm(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle user-confirmation of discovered node."""
if user_input is not None:

6
homeassistant/components/opensky/config_flow.py
View File

@ -11,6 +11,7 @@ import voluptuous as vol
from homeassistant.config_entries import (
ConfigEntry,
ConfigFlow,
ConfigFlowResult,
OptionsFlowWithConfigEntry,
)
from homeassistant.const import (
@ -22,7 +23,6 @@ from homeassistant.const import (
CONF_USERNAME,
)
from homeassistant.core import callback
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers.aiohttp_client import async_get_clientsession
import homeassistant.helpers.config_validation as cv
@ -48,7 +48,7 @@ class OpenSkyConfigFlowHandler(ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Initialize user input."""
if user_input is not None:
return self.async_create_entry(
@ -87,7 +87,7 @@ class OpenSkyOptionsFlowHandler(OptionsFlowWithConfigEntry):
async def async_step_init(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Initialize form."""
errors: dict[str, str] = {}
if user_input is not None:

10
homeassistant/components/opentherm_gw/config_flow.py
View File

@ -8,7 +8,7 @@ from pyotgw import vars as gw_vars
from serial import SerialException
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.config_entries import ConfigEntry, ConfigFlow, OptionsFlow
from homeassistant.const import (
CONF_DEVICE,
CONF_ID,
@ -30,7 +30,7 @@ from .const import (
)
class OpenThermGwConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class OpenThermGwConfigFlow(ConfigFlow, domain=DOMAIN):
"""OpenTherm Gateway Config Flow."""
VERSION = 1
@ -38,7 +38,7 @@ class OpenThermGwConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
@staticmethod
@callback
def async_get_options_flow(
config_entry: config_entries.ConfigEntry,
config_entry: ConfigEntry,
) -> OpenThermGwOptionsFlow:
"""Get the options flow for this handler."""
return OpenThermGwOptionsFlow(config_entry)
@ -116,10 +116,10 @@ class OpenThermGwConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
)
class OpenThermGwOptionsFlow(config_entries.OptionsFlow):
class OpenThermGwOptionsFlow(OptionsFlow):
"""Handle opentherm_gw options."""
def __init__(self, config_entry: config_entries.ConfigEntry) -> None:
def __init__(self, config_entry: ConfigEntry) -> None:
"""Initialize the options flow."""
self.config_entry = config_entry

16
homeassistant/components/openuv/config_flow.py
View File

@ -9,8 +9,7 @@ from pyopenuv import Client
from pyopenuv.errors import OpenUvError
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.config_entries import ConfigEntry
from homeassistant.config_entries import ConfigEntry, ConfigFlow, ConfigFlowResult
from homeassistant.const import (
CONF_API_KEY,
CONF_ELEVATION,
@ -18,7 +17,6 @@ from homeassistant.const import (
CONF_LONGITUDE,
)
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.schema_config_entry_flow import (
SchemaFlowFormStep,
@ -70,7 +68,7 @@ class OpenUvData:
return f"{self.latitude}, {self.longitude}"
class OpenUvFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
class OpenUvFlowHandler(ConfigFlow, domain=DOMAIN):
"""Handle an OpenUV config flow."""
VERSION = 2
@ -99,7 +97,7 @@ class OpenUvFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def _async_verify(
self, data: OpenUvData, error_step_id: str, error_schema: vol.Schema
) -> FlowResult:
) -> ConfigFlowResult:
"""Verify the credentials and create/re-auth the entry."""
websession = aiohttp_client.async_get_clientsession(self.hass)
client = Client(data.api_key, 0, 0, session=websession)
@ -138,14 +136,16 @@ class OpenUvFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
"""Define the config flow to handle options."""
return SchemaOptionsFlowHandler(config_entry, OPTIONS_FLOW)
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."""
self._reauth_data = entry_data
return await self.async_step_reauth_confirm()
async def async_step_reauth_confirm(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle re-auth completion."""
if not user_input:
return self.async_show_form(
@ -168,7 +168,7 @@ class OpenUvFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the start of the config flow."""
if not user_input:
return self.async_show_form(

10
homeassistant/components/openweathermap/config_flow.py
View File

@ -5,7 +5,7 @@ from pyowm import OWM
from pyowm.commons.exceptions import APIRequestError, UnauthorizedError
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.config_entries import ConfigEntry, ConfigFlow, OptionsFlow
from homeassistant.const import (
CONF_API_KEY,
CONF_LANGUAGE,
@ -28,7 +28,7 @@ from .const import (
)
class OpenWeatherMapConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class OpenWeatherMapConfigFlow(ConfigFlow, domain=DOMAIN):
"""Config flow for OpenWeatherMap."""
VERSION = CONFIG_FLOW_VERSION
@ -36,7 +36,7 @@ class OpenWeatherMapConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
@staticmethod
@callback
def async_get_options_flow(
config_entry: config_entries.ConfigEntry,
config_entry: ConfigEntry,
) -> OpenWeatherMapOptionsFlow:
"""Get the options flow for this handler."""
return OpenWeatherMapOptionsFlow(config_entry)
@ -90,10 +90,10 @@ class OpenWeatherMapConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
return self.async_show_form(step_id="user", data_schema=schema, errors=errors)
class OpenWeatherMapOptionsFlow(config_entries.OptionsFlow):
class OpenWeatherMapOptionsFlow(OptionsFlow):
"""Handle options."""
def __init__(self, config_entry: config_entries.ConfigEntry) -> None:
def __init__(self, config_entry: ConfigEntry) -> None:
"""Initialize options flow."""
self.config_entry = config_entry

19
homeassistant/components/opower/config_flow.py
View File

@ -15,10 +15,9 @@ from opower import (
)
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.config_entries import ConfigEntry, ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
from homeassistant.core import HomeAssistant, callback
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers.aiohttp_client import async_create_clientsession
from .const import CONF_TOTP_SECRET, CONF_UTILITY, DOMAIN
@ -55,19 +54,19 @@ async def _validate_login(
return errors
class OpowerConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class OpowerConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Opower."""
VERSION = 1
def __init__(self) -> None:
"""Initialize a new OpowerConfigFlow."""
self.reauth_entry: config_entries.ConfigEntry | None = None
self.reauth_entry: ConfigEntry | None = None
self.utility_info: dict[str, Any] | None = None
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the initial step."""
errors: dict[str, str] = {}
if user_input is not None:
@ -91,7 +90,7 @@ class OpowerConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_mfa(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle MFA step."""
assert self.utility_info is not None
errors: dict[str, str] = {}
@ -120,14 +119,16 @@ class OpowerConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
)
@callback
def _async_create_opower_entry(self, data: dict[str, Any]) -> FlowResult:
def _async_create_opower_entry(self, data: dict[str, Any]) -> ConfigFlowResult:
"""Create the config entry."""
return self.async_create_entry(
title=f"{data[CONF_UTILITY]} ({data[CONF_USERNAME]})",
data=data,
)
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."""
self.reauth_entry = self.hass.config_entries.async_get_entry(
self.context["entry_id"]
@ -136,7 +137,7 @@ class OpowerConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_reauth_confirm(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Dialog that informs the user that reauth is required."""
assert self.reauth_entry
errors: dict[str, str] = {}

9
homeassistant/components/oralb/config_flow.py
View File

@ -10,9 +10,8 @@ from homeassistant.components.bluetooth import (
BluetoothServiceInfoBleak,
async_discovered_service_info,
)
from homeassistant.config_entries import ConfigFlow
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_ADDRESS
from homeassistant.data_entry_flow import FlowResult
from .const import DOMAIN
@ -30,7 +29,7 @@ class OralBConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_bluetooth(
self, discovery_info: BluetoothServiceInfoBleak
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the bluetooth discovery step."""
await self.async_set_unique_id(discovery_info.address)
self._abort_if_unique_id_configured()
@ -43,7 +42,7 @@ class OralBConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_bluetooth_confirm(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Confirm discovery."""
assert self._discovered_device is not None
device = self._discovered_device
@ -62,7 +61,7 @@ class OralBConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the user step to pick discovered device."""
if user_input is not None:
address = user_input[CONF_ADDRESS]

22
homeassistant/components/osoenergy/config_flow.py
View File

@ -6,10 +6,13 @@ from typing import Any
from apyosoenergyapi import OSOEnergy
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.config_entries import ConfigEntry
from homeassistant.config_entries import (
SOURCE_REAUTH,
ConfigEntry,
ConfigFlow,
ConfigFlowResult,
)
from homeassistant.const import CONF_API_KEY
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers import aiohttp_client
from .const import DOMAIN
@ -18,7 +21,7 @@ _LOGGER = logging.getLogger(__name__)
_SCHEMA_STEP_USER = vol.Schema({vol.Required(CONF_API_KEY): str})
class OSOEnergyFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
class OSOEnergyFlowHandler(ConfigFlow, domain=DOMAIN):
"""Handle a OSO Energy config flow."""
VERSION = 1
@ -27,7 +30,7 @@ class OSOEnergyFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
"""Initialize."""
self.entry: ConfigEntry | None = None
async def async_step_user(self, user_input=None) -> FlowResult:
async def async_step_user(self, user_input=None) -> ConfigFlowResult:
"""Handle a flow initialized by the user."""
errors = {}
@ -36,10 +39,7 @@ class OSOEnergyFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
if user_email := await self.get_user_email(user_input[CONF_API_KEY]):
await self.async_set_unique_id(user_email)
if (
self.context["source"] == config_entries.SOURCE_REAUTH
and self.entry
):
if self.context["source"] == SOURCE_REAUTH and self.entry:
self.hass.config_entries.async_update_entry(
self.entry, title=user_email, data=user_input
)
@ -67,7 +67,9 @@ class OSOEnergyFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
_LOGGER.exception("Unknown error occurred")
return None
async def async_step_reauth(self, user_input: Mapping[str, Any]) -> FlowResult:
async def async_step_reauth(
self, user_input: Mapping[str, Any]
) -> ConfigFlowResult:
"""Re Authenticate a user."""
self.entry = self.hass.config_entries.async_get_entry(self.context["entry_id"])
data = {CONF_API_KEY: user_input[CONF_API_KEY]}

9
homeassistant/components/otbr/config_flow.py
View File

@ -19,10 +19,9 @@ from homeassistant.components.hassio import (
)
from homeassistant.components.homeassistant_yellow import hardware as yellow_hardware
from homeassistant.components.thread import async_get_preferred_dataset
from homeassistant.config_entries import SOURCE_HASSIO, ConfigFlow
from homeassistant.config_entries import SOURCE_HASSIO, ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_URL
from homeassistant.core import HomeAssistant
from homeassistant.data_entry_flow import FlowResult
from homeassistant.exceptions import HomeAssistantError
from homeassistant.helpers.aiohttp_client import async_get_clientsession
@ -100,7 +99,7 @@ class OTBRConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, str] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Set up by user."""
if self._async_current_entries():
return self.async_abort(reason="single_instance_allowed")
@ -129,7 +128,9 @@ class OTBRConfigFlow(ConfigFlow, domain=DOMAIN):
step_id="user", data_schema=data_schema, errors=errors
)
async def async_step_hassio(self, discovery_info: HassioServiceInfo) -> FlowResult:
async def async_step_hassio(
self, discovery_info: HassioServiceInfo
) -> ConfigFlowResult:
"""Handle hassio discovery."""
config = discovery_info.config
url = f"http://{config['host']}:{config['port']}"

7
homeassistant/components/ourgroceries/config_flow.py
View File

@ -9,9 +9,8 @@ from ourgroceries import OurGroceries
from ourgroceries.exceptions import InvalidLoginException
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
from homeassistant.data_entry_flow import FlowResult
from .const import DOMAIN
@ -25,14 +24,14 @@ STEP_USER_DATA_SCHEMA = vol.Schema(
)
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class OurGroceriesConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for OurGroceries."""
VERSION = 1
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the initial step."""
errors: dict[str, str] = {}
if user_input is not None:

26
homeassistant/components/overkiz/config_flow.py
View File

@ -22,9 +22,8 @@ from pyoverkiz.obfuscate import obfuscate_id
from pyoverkiz.utils import generate_local_server, is_overkiz_gateway
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.components import dhcp, zeroconf
from homeassistant.config_entries import ConfigEntry
from homeassistant.config_entries import ConfigEntry, ConfigFlow, ConfigFlowResult
from homeassistant.const import (
CONF_HOST,
CONF_PASSWORD,
@ -32,7 +31,6 @@ from homeassistant.const import (
CONF_USERNAME,
CONF_VERIFY_SSL,
)
from homeassistant.data_entry_flow import FlowResult
from homeassistant.exceptions import HomeAssistantError
from homeassistant.helpers.aiohttp_client import async_create_clientsession
@ -43,7 +41,7 @@ class DeveloperModeDisabled(HomeAssistantError):
"""Error to indicate Somfy Developer Mode is disabled."""
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class OverkizConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Overkiz (by Somfy)."""
VERSION = 1
@ -84,7 +82,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the initial step via config flow."""
if user_input:
self._server = user_input[CONF_HUB]
@ -109,7 +107,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_local_or_cloud(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Users can choose between local API or cloud API via config flow."""
if user_input:
self._api_type = user_input[CONF_API_TYPE]
@ -135,7 +133,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_cloud(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the cloud authentication step via config flow."""
errors: dict[str, str] = {}
description_placeholders = {}
@ -217,7 +215,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_local(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the local authentication step via config flow."""
errors = {}
description_placeholders = {}
@ -300,7 +298,9 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
errors=errors,
)
async def async_step_dhcp(self, discovery_info: dhcp.DhcpServiceInfo) -> FlowResult:
async def async_step_dhcp(
self, discovery_info: dhcp.DhcpServiceInfo
) -> ConfigFlowResult:
"""Handle DHCP discovery."""
hostname = discovery_info.hostname
gateway_id = hostname[8:22]
@ -311,7 +311,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_zeroconf(
self, discovery_info: zeroconf.ZeroconfServiceInfo
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle ZeroConf discovery."""
properties = discovery_info.properties
gateway_id = properties["gateway_pin"]
@ -333,7 +333,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
return await self._process_discovery(gateway_id)
async def _process_discovery(self, gateway_id: str) -> FlowResult:
async def _process_discovery(self, gateway_id: str) -> ConfigFlowResult:
"""Handle discovery of a gateway."""
await self.async_set_unique_id(gateway_id)
self._abort_if_unique_id_configured()
@ -341,7 +341,9 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
return await self.async_step_user()
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."""
self._reauth_entry = cast(
ConfigEntry,

7
homeassistant/components/ovo_energy/config_flow.py
View File

@ -8,9 +8,8 @@ import aiohttp
from ovoenergy.ovoenergy import OVOEnergy
import voluptuous as vol
from homeassistant.config_entries import ConfigFlow
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
from homeassistant.data_entry_flow import FlowResult
from .const import CONF_ACCOUNT, DOMAIN
@ -37,7 +36,7 @@ class OVOEnergyFlowHandler(ConfigFlow, domain=DOMAIN):
async def async_step_user(
self,
user_input: Mapping[str, Any] | None = None,
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle a flow initiated by the user."""
errors = {}
if user_input is not None:
@ -73,7 +72,7 @@ class OVOEnergyFlowHandler(ConfigFlow, domain=DOMAIN):
async def async_step_reauth(
self,
user_input: Mapping[str, Any],
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle configuration by re-auth."""
errors = {}

4
homeassistant/components/owntracks/config_flow.py
View File

@ -1,8 +1,8 @@
"""Config flow for OwnTracks."""
import secrets
from homeassistant import config_entries
from homeassistant.components import cloud, webhook
from homeassistant.config_entries import ConfigFlow
from homeassistant.const import CONF_WEBHOOK_ID
from .const import DOMAIN
@ -12,7 +12,7 @@ CONF_SECRET = "secret"
CONF_CLOUDHOOK = "cloudhook"
class OwnTracksFlow(config_entries.ConfigFlow, domain=DOMAIN):
class OwnTracksFlow(ConfigFlow, domain=DOMAIN):
"""Set up OwnTracks."""
VERSION = 1

5
homeassistant/components/p1_monitor/config_flow.py
View File

@ -6,9 +6,8 @@ from typing import Any
from p1monitor import P1Monitor, P1MonitorError
import voluptuous as vol
from homeassistant.config_entries import ConfigFlow
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_HOST
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers.aiohttp_client import async_get_clientsession
from homeassistant.helpers.selector import TextSelector
@ -22,7 +21,7 @@ class P1MonitorFlowHandler(ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle a flow initialized by the user."""
errors = {}

4
homeassistant/components/panasonic_viera/config_flow.py
View File

@ -6,7 +6,7 @@ from urllib.error import URLError
from panasonic_viera import TV_TYPE_ENCRYPTED, RemoteControl, SOAPError
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.config_entries import ConfigFlow
from homeassistant.const import CONF_HOST, CONF_NAME, CONF_PIN, CONF_PORT
from .const import (
@ -25,7 +25,7 @@ from .const import (
_LOGGER = logging.getLogger(__name__)
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class PanasonicVieraConfigFlow(ConfigFlow, domain=DOMAIN):
"""Config flow for Panasonic Viera."""
VERSION = 1

9
homeassistant/components/peco/config_flow.py
View File

@ -12,8 +12,7 @@ from peco import (
)
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.data_entry_flow import FlowResult
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.helpers import config_validation as cv
from .const import CONF_COUNTY, CONF_PHONE_NUMBER, COUNTY_LIST, DOMAIN
@ -28,7 +27,7 @@ STEP_USER_DATA_SCHEMA = vol.Schema(
_LOGGER = logging.getLogger(__name__)
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class PecoConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for PECO Outage Counter."""
VERSION = 1
@ -54,7 +53,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the initial step."""
if user_input is None:
return self.async_show_form(
@ -90,7 +89,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_finish_smart_meter(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the finish smart meter step."""
if "phone_number" in self.meter_error:
if self.meter_error["type"] == "error":

11
homeassistant/components/pegel_online/config_flow.py
View File

@ -6,7 +6,7 @@ from typing import Any
from aiopegelonline import CONNECT_ERRORS, PegelOnline
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import (
CONF_LATITUDE,
CONF_LOCATION,
@ -14,7 +14,6 @@ from homeassistant.const import (
CONF_RADIUS,
UnitOfLength,
)
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers.aiohttp_client import async_get_clientsession
from homeassistant.helpers.selector import (
LocationSelector,
@ -29,7 +28,7 @@ from homeassistant.helpers.selector import (
from .const import CONF_STATION, DEFAULT_RADIUS, DOMAIN
class FlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
class FlowHandler(ConfigFlow, domain=DOMAIN):
"""Handle a config flow."""
VERSION = 1
@ -42,7 +41,7 @@ class FlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle a flow initialized by the user."""
if not user_input:
return self._show_form_user()
@ -69,7 +68,7 @@ class FlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_select_station(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the step select_station of a flow initialized by the user."""
if not user_input:
stations = [
@ -101,7 +100,7 @@ class FlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
self,
user_input: dict[str, Any] | None = None,
errors: dict[str, Any] | None = None,
) -> FlowResult:
) -> ConfigFlowResult:
if user_input is None:
user_input = {}
return self.async_show_form(

15
homeassistant/components/permobil/config_flow.py
View File

@ -13,10 +13,9 @@ from mypermobil import (
)
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_CODE, CONF_EMAIL, CONF_REGION, CONF_TOKEN, CONF_TTL
from homeassistant.core import HomeAssistant, async_get_hass
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers import selector
from homeassistant.helpers.aiohttp_client import async_get_clientsession
import homeassistant.helpers.config_validation as cv
@ -41,7 +40,7 @@ GET_EMAIL_SCHEMA = vol.Schema(
GET_TOKEN_SCHEMA = vol.Schema({vol.Required(CONF_CODE): cv.string})
class PermobilConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class PermobilConfigFlow(ConfigFlow, domain=DOMAIN):
"""Permobil config flow."""
VERSION = 1
@ -56,7 +55,7 @@ class PermobilConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Invoke when a user initiates a flow via the user interface."""
errors: dict[str, str] = {}
@ -80,7 +79,7 @@ class PermobilConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_region(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Invoke when a user initiates a flow via the user interface."""
errors: dict[str, str] = {}
if not user_input:
@ -130,7 +129,7 @@ class PermobilConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_email_code(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Second step in config flow to enter the email code."""
errors: dict[str, str] = {}
@ -160,7 +159,9 @@ class PermobilConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
return self.async_create_entry(title=self.data[CONF_EMAIL], data=self.data)
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."""
reauth_entry = self.hass.config_entries.async_get_entry(
self.context["entry_id"]

24
homeassistant/components/philips_js/config_flow.py
View File

@ -8,7 +8,7 @@ from typing import Any
from haphilipsjs import ConnectionFailure, PairingFailure, PhilipsTV
import voluptuous as vol
from homeassistant import config_entries, core
from homeassistant.config_entries import ConfigEntry, ConfigFlow, ConfigFlowResult
from homeassistant.const import (
CONF_API_VERSION,
CONF_HOST,
@ -16,7 +16,7 @@ from homeassistant.const import (
CONF_PIN,
CONF_USERNAME,
)
from homeassistant.data_entry_flow import FlowResult
from homeassistant.core import HomeAssistant, callback
from homeassistant.helpers import selector
from homeassistant.helpers.schema_config_entry_flow import (
SchemaFlowFormStep,
@ -49,7 +49,7 @@ OPTIONS_FLOW = {
async def _validate_input(
hass: core.HomeAssistant, host: str, api_version: int
hass: HomeAssistant, host: str, api_version: int
) -> PhilipsTV:
"""Validate the user input allows us to connect."""
hub = PhilipsTV(host, api_version)
@ -63,7 +63,7 @@ async def _validate_input(
return hub
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class PhilipsJSConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Philips TV."""
VERSION = 1
@ -74,9 +74,9 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
self._current: dict[str, Any] = {}
self._hub: PhilipsTV | None = None
self._pair_state: Any = None
self._entry: config_entries.ConfigEntry | None = None
self._entry: ConfigEntry | None = None
async def _async_create_current(self) -> FlowResult:
async def _async_create_current(self) -> ConfigFlowResult:
system = self._current[CONF_SYSTEM]
if self._entry:
self.hass.config_entries.async_update_entry(
@ -94,7 +94,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_pair(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Attempt to pair with device."""
assert self._hub
@ -145,7 +145,9 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
self._current[CONF_PASSWORD] = password
return await self._async_create_current()
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."""
self._entry = self.hass.config_entries.async_get_entry(self.context["entry_id"])
self._current[CONF_HOST] = entry_data[CONF_HOST]
@ -154,7 +156,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the initial step."""
errors = {}
if user_input:
@ -187,9 +189,9 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
return self.async_show_form(step_id="user", data_schema=schema, errors=errors)
@staticmethod
@core.callback
@callback
def async_get_options_flow(
config_entry: config_entries.ConfigEntry,
config_entry: ConfigEntry,
) -> SchemaOptionsFlowHandler:
"""Get the options flow for this handler."""
return SchemaOptionsFlowHandler(config_entry, OPTIONS_FLOW)

15
homeassistant/components/pi_hole/config_flow.py
View File

@ -9,7 +9,7 @@ from hole import Hole
from hole.exceptions import HoleError
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import (
CONF_API_KEY,
CONF_HOST,
@ -19,7 +19,6 @@ from homeassistant.const import (
CONF_SSL,
CONF_VERIFY_SSL,
)
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers.aiohttp_client import async_get_clientsession
from .const import (
@ -33,7 +32,7 @@ from .const import (
_LOGGER = logging.getLogger(__name__)
class PiHoleFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
class PiHoleFlowHandler(ConfigFlow, domain=DOMAIN):
"""Handle a Pi-hole config flow."""
VERSION = 1
@ -44,7 +43,7 @@ class PiHoleFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle a flow initiated by the user."""
errors = {}
@ -103,7 +102,7 @@ class PiHoleFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_api_key(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle step to setup API key."""
errors = {}
if user_input is not None:
@ -120,7 +119,9 @@ class PiHoleFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
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."""
self._config = dict(entry_data)
return await self.async_step_reauth_confirm()
@ -128,7 +129,7 @@ class PiHoleFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_reauth_confirm(
self,
user_input: dict[str, Any] | None = None,
) -> FlowResult:
) -> ConfigFlowResult:
"""Perform reauth confirm upon an API authentication error."""
errors = {}
if user_input is not None:

18
homeassistant/components/picnic/config_flow.py
View File

@ -10,15 +10,15 @@ from python_picnic_api.session import PicnicAuthError
import requests
import voluptuous as vol
from homeassistant import config_entries, core, exceptions
from homeassistant.config_entries import SOURCE_REAUTH
from homeassistant.config_entries import SOURCE_REAUTH, ConfigFlow, ConfigFlowResult
from homeassistant.const import (
CONF_ACCESS_TOKEN,
CONF_COUNTRY_CODE,
CONF_PASSWORD,
CONF_USERNAME,
)
from homeassistant.data_entry_flow import FlowResult
from homeassistant.core import HomeAssistant
from homeassistant.exceptions import HomeAssistantError
from .const import COUNTRY_CODES, DOMAIN
@ -45,7 +45,7 @@ class PicnicHub:
return picnic.session.auth_token, picnic.get_user()
async def validate_input(hass: core.HomeAssistant, data):
async def validate_input(hass: HomeAssistant, data):
"""Validate the user input allows us to connect.
Data has the keys from STEP_USER_DATA_SCHEMA with values provided by the user.
@ -75,12 +75,14 @@ async def validate_input(hass: core.HomeAssistant, data):
}
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class PicnicConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Picnic."""
VERSION = 1
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 the re-auth step upon an API authentication error."""
return await self.async_step_user()
@ -128,9 +130,9 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
)
class CannotConnect(exceptions.HomeAssistantError):
class CannotConnect(HomeAssistantError):
"""Error to indicate we cannot connect."""
class InvalidAuth(exceptions.HomeAssistantError):
class InvalidAuth(HomeAssistantError):
"""Error to indicate there is invalid auth."""

26
homeassistant/components/ping/config_flow.py
View File

@ -7,14 +7,18 @@ from typing import Any
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.components.device_tracker import (
CONF_CONSIDER_HOME,
DEFAULT_CONSIDER_HOME,
)
from homeassistant.config_entries import (
ConfigEntry,
ConfigFlow,
ConfigFlowResult,
OptionsFlow,
)
from homeassistant.const import CONF_HOST, CONF_NAME
from homeassistant.core import callback
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers import selector
from homeassistant.util.network import is_ip_address
@ -23,14 +27,14 @@ from .const import CONF_IMPORTED_BY, CONF_PING_COUNT, DEFAULT_PING_COUNT, DOMAIN
_LOGGER = logging.getLogger(__name__)
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class PingConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Ping."""
VERSION = 1
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the initial step."""
if user_input is None:
return self.async_show_form(
@ -56,7 +60,9 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
},
)
async def async_step_import(self, import_info: Mapping[str, Any]) -> FlowResult:
async def async_step_import(
self, import_info: Mapping[str, Any]
) -> ConfigFlowResult:
"""Import an entry."""
to_import = {
@ -78,22 +84,22 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
@staticmethod
@callback
def async_get_options_flow(
config_entry: config_entries.ConfigEntry,
) -> config_entries.OptionsFlow:
config_entry: ConfigEntry,
) -> OptionsFlow:
"""Create the options flow."""
return OptionsFlowHandler(config_entry)
class OptionsFlowHandler(config_entries.OptionsFlow):
class OptionsFlowHandler(OptionsFlow):
"""Handle an options flow for Ping."""
def __init__(self, config_entry: config_entries.ConfigEntry) -> None:
def __init__(self, config_entry: ConfigEntry) -> None:
"""Initialize options flow."""
self.config_entry = config_entry
async def async_step_init(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Manage the options."""
if user_input is not None:
return self.async_create_entry(title="", data=user_input)

7
homeassistant/components/plaato/config_flow.py
View File

@ -4,9 +4,8 @@ from __future__ import annotations
from pyplaato.plaato import PlaatoDeviceType
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.components import cloud, webhook
from homeassistant.config_entries import ConfigEntry
from homeassistant.config_entries import ConfigEntry, ConfigFlow, OptionsFlow
from homeassistant.const import CONF_SCAN_INTERVAL, CONF_TOKEN, CONF_WEBHOOK_ID
from homeassistant.core import callback
import homeassistant.helpers.config_validation as cv
@ -26,7 +25,7 @@ from .const import (
)
class PlaatoConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class PlaatoConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handles a Plaato config flow."""
VERSION = 1
@ -168,7 +167,7 @@ class PlaatoConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
return PlaatoOptionsFlowHandler(config_entry)
class PlaatoOptionsFlowHandler(config_entries.OptionsFlow):
class PlaatoOptionsFlowHandler(OptionsFlow):
"""Handle Plaato options."""
def __init__(self, config_entry: ConfigEntry) -> None:

26
homeassistant/components/plex/config_flow.py
View File

@ -13,10 +13,17 @@ from plexauth import PlexAuth
import requests.exceptions
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.components import http
from homeassistant.components.http.view import HomeAssistantView
from homeassistant.components.media_player import DOMAIN as MP_DOMAIN
from homeassistant.config_entries import (
SOURCE_INTEGRATION_DISCOVERY,
SOURCE_REAUTH,
ConfigEntry,
ConfigFlow,
ConfigFlowResult,
OptionsFlow,
)
from homeassistant.const import (
CONF_CLIENT_ID,
CONF_HOST,
@ -28,7 +35,6 @@ from homeassistant.const import (
CONF_VERIFY_SSL,
)
from homeassistant.core import callback
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers import discovery_flow
from homeassistant.helpers.aiohttp_client import async_get_clientsession
import homeassistant.helpers.config_validation as cv
@ -80,12 +86,12 @@ async def async_discover(hass):
discovery_flow.async_create_flow(
hass,
DOMAIN,
context={CONF_SOURCE: config_entries.SOURCE_INTEGRATION_DISCOVERY},
context={CONF_SOURCE: SOURCE_INTEGRATION_DISCOVERY},
data=server_data,
)
class PlexFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
class PlexFlowHandler(ConfigFlow, domain=DOMAIN):
"""Handle a Plex config flow."""
VERSION = 1
@ -93,7 +99,7 @@ class PlexFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
@staticmethod
@callback
def async_get_options_flow(
config_entry: config_entries.ConfigEntry,
config_entry: ConfigEntry,
) -> PlexOptionsFlowHandler:
"""Get the options flow for this handler."""
return PlexOptionsFlowHandler(config_entry)
@ -241,7 +247,7 @@ class PlexFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
}
entry = await self.async_set_unique_id(server_id)
if self.context[CONF_SOURCE] == config_entries.SOURCE_REAUTH:
if self.context[CONF_SOURCE] == SOURCE_REAUTH:
self.hass.config_entries.async_update_entry(entry, data=data)
_LOGGER.debug("Updated config entry for %s", plex_server.friendly_name)
await self.hass.config_entries.async_reload(entry.entry_id)
@ -338,7 +344,9 @@ class PlexFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
server_config = {CONF_TOKEN: self.token}
return await self.async_step_server_validate(server_config)
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 reauthorization flow request."""
self._reauth_config = {
CONF_SERVER_IDENTIFIER: entry_data[CONF_SERVER_IDENTIFIER]
@ -346,10 +354,10 @@ class PlexFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
return await self.async_step_user()
class PlexOptionsFlowHandler(config_entries.OptionsFlow):
class PlexOptionsFlowHandler(OptionsFlow):
"""Handle Plex options."""
def __init__(self, config_entry: config_entries.ConfigEntry) -> None:
def __init__(self, config_entry: ConfigEntry) -> None:
"""Initialize Plex options flow."""
self.options = copy.deepcopy(dict(config_entry.options))
self.server_id = config_entry.data[CONF_SERVER_IDENTIFIER]

7
homeassistant/components/plugwise/config_flow.py
View File

@ -15,7 +15,7 @@ from plugwise.exceptions import (
import voluptuous as vol
from homeassistant.components.zeroconf import ZeroconfServiceInfo
from homeassistant.config_entries import ConfigFlow
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import (
CONF_BASE,
CONF_HOST,
@ -25,7 +25,6 @@ from homeassistant.const import (
CONF_USERNAME,
)
from homeassistant.core import HomeAssistant
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers.aiohttp_client import async_get_clientsession
from .const import (
@ -89,7 +88,7 @@ class PlugwiseConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_zeroconf(
self, discovery_info: ZeroconfServiceInfo
) -> FlowResult:
) -> ConfigFlowResult:
"""Prepare configuration for a discovered Plugwise Smile."""
self.discovery_info = discovery_info
_properties = discovery_info.properties
@ -166,7 +165,7 @@ class PlugwiseConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the initial step when using network/gateway setups."""
errors = {}

7
homeassistant/components/plum_lightpad/config_flow.py
View File

@ -8,9 +8,8 @@ from aiohttp import ContentTypeError
from requests.exceptions import ConnectTimeout, HTTPError
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
from homeassistant.data_entry_flow import FlowResult
from .const import DOMAIN
from .utils import load_plum
@ -18,7 +17,7 @@ from .utils import load_plum
_LOGGER = logging.getLogger(__name__)
class PlumLightpadConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class PlumLightpadConfigFlow(ConfigFlow, domain=DOMAIN):
"""Config flow for Plum Lightpad integration."""
VERSION = 1
@ -37,7 +36,7 @@ class PlumLightpadConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle a flow initialized by the user or redirected to by import."""
if not user_input:
return self._show_form()

4
homeassistant/components/point/config_flow.py
View File

@ -6,8 +6,8 @@ import logging
from pypoint import PointSession
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.components.http import HomeAssistantView
from homeassistant.config_entries import ConfigFlow
from homeassistant.const import CONF_CLIENT_ID, CONF_CLIENT_SECRET
from homeassistant.core import callback
from homeassistant.helpers.aiohttp_client import async_get_clientsession
@ -40,7 +40,7 @@ def register_flow_implementation(hass, domain, client_id, client_secret):
}
class PointFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
class PointFlowHandler(ConfigFlow, domain=DOMAIN):
"""Handle a config flow."""
VERSION = 1

7
homeassistant/components/poolsense/config_flow.py
View File

@ -5,9 +5,8 @@ from typing import Any
from poolsense import PoolSense
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_EMAIL, CONF_PASSWORD
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers import aiohttp_client
from .const import DOMAIN
@ -15,7 +14,7 @@ from .const import DOMAIN
_LOGGER = logging.getLogger(__name__)
class PoolSenseConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class PoolSenseConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for PoolSense."""
VERSION = 1
@ -25,7 +24,7 @@ class PoolSenseConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the initial step."""
errors = {}

42
homeassistant/components/powerwall/config_flow.py
View File

@ -16,10 +16,16 @@ from tesla_powerwall import (
)
import voluptuous as vol
from homeassistant import config_entries, core, exceptions
from homeassistant.components import dhcp
from homeassistant.config_entries import (
ConfigEntry,
ConfigEntryState,
ConfigFlow,
ConfigFlowResult,
)
from homeassistant.const import CONF_IP_ADDRESS, CONF_PASSWORD
from homeassistant.data_entry_flow import FlowResult
from homeassistant.core import HomeAssistant
from homeassistant.exceptions import HomeAssistantError
from homeassistant.helpers.aiohttp_client import async_create_clientsession
from homeassistant.util.network import is_ip_address
@ -30,8 +36,8 @@ _LOGGER = logging.getLogger(__name__)
ENTRY_FAILURE_STATES = {
config_entries.ConfigEntryState.SETUP_ERROR,
config_entries.ConfigEntryState.SETUP_RETRY,
ConfigEntryState.SETUP_ERROR,
ConfigEntryState.SETUP_RETRY,
}
@ -59,9 +65,7 @@ async def _powerwall_is_reachable(ip_address: str, password: str) -> bool:
return True
async def validate_input(
hass: core.HomeAssistant, data: dict[str, str]
) -> dict[str, str]:
async def validate_input(hass: HomeAssistant, data: dict[str, str]) -> dict[str, str]:
"""Validate the user input allows us to connect.
Data has the keys from schema with values provided by the user.
@ -85,7 +89,7 @@ async def validate_input(
return {"title": site_info.site_name, "unique_id": gateway_din.upper()}
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class PowerwallConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Tesla Powerwall."""
VERSION = 1
@ -94,11 +98,9 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
"""Initialize the powerwall flow."""
self.ip_address: str | None = None
self.title: str | None = None
self.reauth_entry: config_entries.ConfigEntry | None = None
self.reauth_entry: ConfigEntry | None = None
async def _async_powerwall_is_offline(
self, entry: config_entries.ConfigEntry
) -> bool:
async def _async_powerwall_is_offline(self, entry: ConfigEntry) -> bool:
"""Check if the power wall is offline.
We define offline by the config entry
@ -113,7 +115,9 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
or not async_last_update_was_successful(self.hass, entry)
) and not await _powerwall_is_reachable(ip_address, password)
async def async_step_dhcp(self, discovery_info: dhcp.DhcpServiceInfo) -> FlowResult:
async def async_step_dhcp(
self, discovery_info: dhcp.DhcpServiceInfo
) -> ConfigFlowResult:
"""Handle dhcp discovery."""
self.ip_address = discovery_info.ip
gateway_din = discovery_info.hostname.upper()
@ -180,7 +184,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_confirm_discovery(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Confirm a discovered powerwall."""
assert self.ip_address is not None
assert self.unique_id is not None
@ -209,7 +213,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the initial step."""
errors: dict[str, str] | None = {}
description_placeholders: dict[str, str] = {}
@ -243,7 +247,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_reauth_confirm(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle reauth confirmation."""
assert self.reauth_entry is not None
errors: dict[str, str] | None = {}
@ -265,7 +269,9 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
description_placeholders=description_placeholders,
)
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."""
self.reauth_entry = self.hass.config_entries.async_get_entry(
self.context["entry_id"]
@ -273,5 +279,5 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
return await self.async_step_reauth_confirm()
class WrongVersion(exceptions.HomeAssistantError):
class WrongVersion(HomeAssistantError):
"""Error indicating we cannot interact with the powerwall software version."""

5
homeassistant/components/private_ble_device/config_flow.py
View File

@ -8,8 +8,7 @@ import logging
import voluptuous as vol
from homeassistant.components import bluetooth
from homeassistant.config_entries import ConfigFlow
from homeassistant.data_entry_flow import FlowResult
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from .const import DOMAIN
from .coordinator import async_last_service_info
@ -50,7 +49,7 @@ class BLEDeviceTrackerConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, str] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Set up by user."""
errors: dict[str, str] = {}

4
homeassistant/components/profiler/config_flow.py
View File

@ -1,10 +1,10 @@
"""Config flow for Profiler integration."""
from homeassistant import config_entries
from homeassistant.config_entries import ConfigFlow
from .const import DEFAULT_NAME, DOMAIN
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class ProfilerConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Profiler."""
VERSION = 1

14
homeassistant/components/progettihwsw/config_flow.py
View File

@ -3,7 +3,9 @@
from ProgettiHWSW.ProgettiHWSWAPI import ProgettiHWSWAPI
import voluptuous as vol
from homeassistant import config_entries, core, exceptions
from homeassistant.config_entries import ConfigFlow
from homeassistant.core import HomeAssistant
from homeassistant.exceptions import HomeAssistantError
from .const import DOMAIN
@ -12,7 +14,7 @@ DATA_SCHEMA = vol.Schema(
)
async def validate_input(hass: core.HomeAssistant, data):
async def validate_input(hass: HomeAssistant, data):
"""Validate the user host input."""
api_instance = ProgettiHWSWAPI(f'{data["host"]}:{data["port"]}')
@ -29,7 +31,7 @@ async def validate_input(hass: core.HomeAssistant, data):
}
class ProgettiHWSWConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class ProgettiHWSWConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for ProgettiHWSW Automation."""
VERSION = 1
@ -88,13 +90,13 @@ class ProgettiHWSWConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
)
class CannotConnect(exceptions.HomeAssistantError):
class CannotConnect(HomeAssistantError):
"""Error to indicate we cannot identify host."""
class WrongInfo(exceptions.HomeAssistantError):
class WrongInfo(HomeAssistantError):
"""Error to indicate we cannot validate relay modes input."""
class ExistingEntry(exceptions.HomeAssistantError):
class ExistingEntry(HomeAssistantError):
"""Error to indicate we cannot validate relay modes input."""

20
homeassistant/components/prosegur/config_flow.py
View File

@ -7,10 +7,10 @@ from pyprosegur.auth import COUNTRY, Auth
from pyprosegur.installation import Installation
import voluptuous as vol
from homeassistant import config_entries, core, exceptions
from homeassistant.config_entries import ConfigEntry
from homeassistant.config_entries import ConfigEntry, ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_COUNTRY, CONF_PASSWORD, CONF_USERNAME
from homeassistant.data_entry_flow import FlowResult
from homeassistant.core import HomeAssistant
from homeassistant.exceptions import HomeAssistantError
from homeassistant.helpers import aiohttp_client, selector
from .const import CONF_CONTRACT, DOMAIN
@ -28,7 +28,7 @@ STEP_USER_DATA_SCHEMA = vol.Schema(
)
async def validate_input(hass: core.HomeAssistant, data):
async def validate_input(hass: HomeAssistant, data):
"""Validate the user input allows us to connect."""
session = aiohttp_client.async_get_clientsession(hass)
auth = Auth(session, data[CONF_USERNAME], data[CONF_PASSWORD], data[CONF_COUNTRY])
@ -41,7 +41,7 @@ async def validate_input(hass: core.HomeAssistant, data):
raise CannotConnect from ConnectionError
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class ProsegurConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Prosegur Alarm."""
VERSION = 1
@ -74,7 +74,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_choose_contract(
self, user_input: Any | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Let user decide which contract is being setup."""
if user_input:
@ -103,7 +103,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 initiation of re-authentication with Prosegur."""
self.entry = cast(
ConfigEntry,
@ -155,9 +157,9 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
)
class CannotConnect(exceptions.HomeAssistantError):
class CannotConnect(HomeAssistantError):
"""Error to indicate we cannot connect."""
class InvalidAuth(exceptions.HomeAssistantError):
class InvalidAuth(HomeAssistantError):
"""Error to indicate there is invalid auth."""

14
homeassistant/components/proximity/config_flow.py
View File

@ -8,10 +8,14 @@ import voluptuous as vol
from homeassistant.components.device_tracker import DOMAIN as DEVICE_TRACKER_DOMAIN
from homeassistant.components.person import DOMAIN as PERSON_DOMAIN
from homeassistant.components.zone import DOMAIN as ZONE_DOMAIN
from homeassistant.config_entries import ConfigEntry, ConfigFlow, OptionsFlow
from homeassistant.config_entries import (
ConfigEntry,
ConfigFlow,
ConfigFlowResult,
OptionsFlow,
)
from homeassistant.const import CONF_ZONE
from homeassistant.core import State, callback
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers.selector import (
EntitySelector,
EntitySelectorConfig,
@ -85,7 +89,7 @@ class ProximityConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle a flow initialized by the user."""
if user_input is not None:
self._async_abort_entries_match(user_input)
@ -111,7 +115,7 @@ class ProximityConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_import(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Import a yaml config entry."""
return await self.async_step_user(user_input)
@ -128,7 +132,7 @@ class ProximityOptionsFlow(OptionsFlow):
async def async_step_init(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle options flow."""
if user_input is not None:
self.hass.config_entries.async_update_entry(

7
homeassistant/components/prusalink/config_flow.py
View File

@ -11,10 +11,9 @@ from pyprusalink import PrusaLink
from pyprusalink.types import InvalidAuth
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
from homeassistant.core import HomeAssistant
from homeassistant.data_entry_flow import FlowResult
from homeassistant.exceptions import HomeAssistantError
from homeassistant.helpers.aiohttp_client import async_get_clientsession
@ -63,7 +62,7 @@ async def validate_input(hass: HomeAssistant, data: dict[str, str]) -> dict[str,
return {"title": version["hostname"] or version["text"]}
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class PrusaLinkConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for PrusaLink."""
VERSION = 1
@ -71,7 +70,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the initial step."""
if user_input is None:
return self.async_show_form(

4
homeassistant/components/ps4/config_flow.py
View File

@ -6,7 +6,7 @@ from pyps4_2ndscreen.helpers import Helper
from pyps4_2ndscreen.media_art import COUNTRIES
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.config_entries import ConfigFlow
from homeassistant.const import (
CONF_CODE,
CONF_HOST,
@ -38,7 +38,7 @@ PORT_MSG = {UDP_PORT: "port_987_bind_error", TCP_PORT: "port_997_bind_error"}
PIN_LENGTH = 8
class PlayStation4FlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
class PlayStation4FlowHandler(ConfigFlow, domain=DOMAIN):
"""Handle a PlayStation 4 config flow."""
VERSION = CONFIG_ENTRY_VERSION

9
homeassistant/components/pure_energie/config_flow.py
View File

@ -7,9 +7,8 @@ from gridnet import Device, GridNet, GridNetConnectionError
import voluptuous as vol
from homeassistant.components import zeroconf
from homeassistant.config_entries import ConfigFlow
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_HOST, CONF_NAME
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers.aiohttp_client import async_get_clientsession
from homeassistant.helpers.selector import TextSelector
@ -25,7 +24,7 @@ class PureEnergieFlowHandler(ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle a flow initialized by the user."""
errors = {}
@ -59,7 +58,7 @@ class PureEnergieFlowHandler(ConfigFlow, domain=DOMAIN):
async def async_step_zeroconf(
self, discovery_info: zeroconf.ZeroconfServiceInfo
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle zeroconf discovery."""
self.discovered_host = discovery_info.host
try:
@ -83,7 +82,7 @@ class PureEnergieFlowHandler(ConfigFlow, domain=DOMAIN):
async def async_step_zeroconf_confirm(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle a flow initiated by zeroconf."""
if user_input is not None:
return self.async_create_entry(

35
homeassistant/components/purpleair/config_flow.py
View File

@ -12,8 +12,12 @@ from aiopurpleair.endpoints.sensors import NearbySensorResult
from aiopurpleair.errors import InvalidApiKeyError, PurpleAirError
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.config_entries import ConfigEntry
from homeassistant.config_entries import (
ConfigEntry,
ConfigFlow,
ConfigFlowResult,
OptionsFlow,
)
from homeassistant.const import (
CONF_API_KEY,
CONF_LATITUDE,
@ -21,7 +25,6 @@ from homeassistant.const import (
CONF_SHOW_ON_MAP,
)
from homeassistant.core import HomeAssistant, callback
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers import (
aiohttp_client,
config_validation as cv,
@ -193,7 +196,7 @@ async def async_validate_coordinates(
return ValidationResult(data=nearby_sensor_results)
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class PurpleAirConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for PurpleAir."""
VERSION = 1
@ -213,7 +216,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_by_coordinates(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the discovery of sensors near a latitude/longitude."""
if user_input is None:
return self.async_show_form(
@ -243,7 +246,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_choose_sensor(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the selection of a sensor."""
if user_input is None:
options = self._flow_data.pop(CONF_NEARBY_SENSOR_OPTIONS)
@ -260,7 +263,9 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
options={CONF_SENSOR_INDICES: [int(user_input[CONF_SENSOR_INDEX])]},
)
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."""
self._reauth_entry = self.hass.config_entries.async_get_entry(
self.context["entry_id"]
@ -269,7 +274,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_reauth_confirm(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the re-auth step."""
if user_input is None:
return self.async_show_form(
@ -298,7 +303,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the initial step."""
if user_input is None:
return self.async_show_form(step_id="user", data_schema=API_KEY_SCHEMA)
@ -319,7 +324,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
return await self.async_step_by_coordinates()
class PurpleAirOptionsFlowHandler(config_entries.OptionsFlow):
class PurpleAirOptionsFlowHandler(OptionsFlow):
"""Handle a PurpleAir options flow."""
def __init__(self, config_entry: ConfigEntry) -> None:
@ -345,7 +350,7 @@ class PurpleAirOptionsFlowHandler(config_entries.OptionsFlow):
async def async_step_add_sensor(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Add a sensor."""
if user_input is None:
return self.async_show_form(
@ -376,7 +381,7 @@ class PurpleAirOptionsFlowHandler(config_entries.OptionsFlow):
async def async_step_choose_sensor(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Choose a sensor."""
if user_input is None:
options = self._flow_data.pop(CONF_NEARBY_SENSOR_OPTIONS)
@ -396,7 +401,7 @@ class PurpleAirOptionsFlowHandler(config_entries.OptionsFlow):
async def async_step_init(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Manage the options."""
return self.async_show_menu(
step_id="init",
@ -405,7 +410,7 @@ class PurpleAirOptionsFlowHandler(config_entries.OptionsFlow):
async def async_step_remove_sensor(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Remove a sensor."""
if user_input is None:
return self.async_show_form(
@ -467,7 +472,7 @@ class PurpleAirOptionsFlowHandler(config_entries.OptionsFlow):
async def async_step_settings(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Manage settings."""
if user_input is None:
return self.async_show_form(

7
homeassistant/components/pushbullet/config_flow.py
View File

@ -6,9 +6,8 @@ from typing import Any
from pushbullet import InvalidKeyError, PushBullet, PushbulletError
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_API_KEY, CONF_NAME
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers import selector
from .const import DEFAULT_NAME, DOMAIN
@ -21,12 +20,12 @@ CONFIG_SCHEMA = vol.Schema(
)
class PushBulletConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class PushBulletConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for pushbullet integration."""
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the initial step."""
errors = {}

15
homeassistant/components/pushover/config_flow.py
View File

@ -7,10 +7,9 @@ from typing import Any
from pushover_complete import BadAPIRequestError, PushoverAPI
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.config_entries import ConfigEntry, ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_API_KEY, CONF_NAME
from homeassistant.core import HomeAssistant
from homeassistant.data_entry_flow import FlowResult
from .const import CONF_USER_KEY, DEFAULT_NAME, DOMAIN
@ -39,12 +38,14 @@ async def validate_input(hass: HomeAssistant, data: dict[str, Any]) -> dict[str,
return errors
class PushBulletConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class PushBulletConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for pushover integration."""
_reauth_entry: config_entries.ConfigEntry | None
_reauth_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:
"""Perform reauth upon an API authentication error."""
self._reauth_entry = self.hass.config_entries.async_get_entry(
self.context["entry_id"]
@ -53,7 +54,7 @@ class PushBulletConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_reauth_confirm(
self, user_input: dict[str, str] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Confirm reauth dialog."""
errors = {}
if user_input is not None and self._reauth_entry:
@ -84,7 +85,7 @@ class PushBulletConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the initial step."""
errors = {}

11
homeassistant/components/pvoutput/config_flow.py
View File

@ -7,10 +7,9 @@ from typing import Any
from pvo import PVOutput, PVOutputAuthenticationError, PVOutputError
import voluptuous as vol
from homeassistant.config_entries import ConfigEntry, ConfigFlow
from homeassistant.config_entries import ConfigEntry, ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_API_KEY
from homeassistant.core import HomeAssistant
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers.aiohttp_client import async_get_clientsession
from .const import CONF_SYSTEM_ID, DOMAIN, LOGGER
@ -37,7 +36,7 @@ class PVOutputFlowHandler(ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle a flow initialized by the user."""
errors = {}
@ -84,7 +83,9 @@ class PVOutputFlowHandler(ConfigFlow, domain=DOMAIN):
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 initiation of re-authentication with PVOutput."""
self.reauth_entry = self.hass.config_entries.async_get_entry(
self.context["entry_id"]
@ -93,7 +94,7 @@ class PVOutputFlowHandler(ConfigFlow, domain=DOMAIN):
async def async_step_reauth_confirm(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle re-authentication with PVOutput."""
errors = {}

34
homeassistant/components/pvpc_hourly_pricing/config_flow.py
View File

@ -7,10 +7,14 @@ from typing import Any
from aiopvpc import DEFAULT_POWER_KW, PVPCData
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.config_entries import (
ConfigEntry,
ConfigFlow,
ConfigFlowResult,
OptionsFlowWithConfigEntry,
)
from homeassistant.const import CONF_API_TOKEN, CONF_NAME
from homeassistant.core import callback
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers.aiohttp_client import async_get_clientsession
from homeassistant.util import dt as dt_util
@ -32,7 +36,7 @@ _MAIL_TO_LINK = (
)
class TariffSelectorConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class TariffSelectorConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle config flow for `pvpc_hourly_pricing`."""
VERSION = 1
@ -43,19 +47,19 @@ class TariffSelectorConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
_use_api_token: bool = False
_api_token: str | None = None
_api: PVPCData | None = None
_reauth_entry: config_entries.ConfigEntry | None = None
_reauth_entry: ConfigEntry | None = None
@staticmethod
@callback
def async_get_options_flow(
config_entry: config_entries.ConfigEntry,
config_entry: ConfigEntry,
) -> PVPCOptionsFlowHandler:
"""Get the options flow for this handler."""
return PVPCOptionsFlowHandler(config_entry)
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the initial step."""
if user_input is not None:
await self.async_set_unique_id(user_input[ATTR_TARIFF])
@ -92,7 +96,7 @@ class TariffSelectorConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_api_token(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle optional step to define API token for extra sensors."""
if user_input is not None:
self._api_token = user_input[CONF_API_TOKEN]
@ -110,7 +114,9 @@ class TariffSelectorConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
description_placeholders={"mail_to_link": _MAIL_TO_LINK},
)
async def _async_verify(self, step_id: str, data_schema: vol.Schema) -> FlowResult:
async def _async_verify(
self, step_id: str, data_schema: vol.Schema
) -> ConfigFlowResult:
"""Attempt to verify the provided configuration."""
errors: dict[str, str] = {}
auth_ok = True
@ -144,7 +150,9 @@ class TariffSelectorConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
assert self._name is not None
return self.async_create_entry(title=self._name, data=data)
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 ESIOS Token."""
self._reauth_entry = self.hass.config_entries.async_get_entry(
self.context["entry_id"]
@ -159,7 +167,7 @@ class TariffSelectorConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_reauth_confirm(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Confirm reauth dialog."""
data_schema = vol.Schema(
{
@ -174,7 +182,7 @@ class TariffSelectorConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
return self.async_show_form(step_id="reauth_confirm", data_schema=data_schema)
class PVPCOptionsFlowHandler(config_entries.OptionsFlowWithConfigEntry):
class PVPCOptionsFlowHandler(OptionsFlowWithConfigEntry):
"""Handle PVPC options."""
_power: float | None = None
@ -182,7 +190,7 @@ class PVPCOptionsFlowHandler(config_entries.OptionsFlowWithConfigEntry):
async def async_step_api_token(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle optional step to define API token for extra sensors."""
if user_input is not None and user_input.get(CONF_API_TOKEN):
return self.async_create_entry(
@ -208,7 +216,7 @@ class PVPCOptionsFlowHandler(config_entries.OptionsFlowWithConfigEntry):
async def async_step_init(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Manage the options."""
if user_input is not None:
if user_input[CONF_USE_API_TOKEN]:

5
homeassistant/components/qbittorrent/config_flow.py
View File

@ -8,9 +8,8 @@ from qbittorrent.client import LoginRequired
from requests.exceptions import RequestException
import voluptuous as vol
from homeassistant.config_entries import ConfigFlow
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_PASSWORD, CONF_URL, CONF_USERNAME, CONF_VERIFY_SSL
from homeassistant.data_entry_flow import FlowResult
from .const import DEFAULT_NAME, DEFAULT_URL, DOMAIN
from .helpers import setup_client
@ -32,7 +31,7 @@ class QbittorrentConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle a user-initiated config flow."""
errors = {}

9
homeassistant/components/qingping/config_flow.py
View File

@ -12,9 +12,8 @@ from homeassistant.components.bluetooth import (
async_discovered_service_info,
async_process_advertisements,
)
from homeassistant.config_entries import ConfigFlow
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_ADDRESS
from homeassistant.data_entry_flow import FlowResult
from .const import DOMAIN
@ -52,7 +51,7 @@ class QingpingConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_bluetooth(
self, discovery_info: BluetoothServiceInfoBleak
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the bluetooth discovery step."""
await self.async_set_unique_id(discovery_info.address)
self._abort_if_unique_id_configured()
@ -69,7 +68,7 @@ class QingpingConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_bluetooth_confirm(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Confirm discovery."""
assert self._discovered_device is not None
device = self._discovered_device
@ -88,7 +87,7 @@ class QingpingConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the user step to pick discovered device."""
if user_input is not None:
address = user_input[CONF_ADDRESS]

7
homeassistant/components/qnap/config_flow.py
View File

@ -8,7 +8,7 @@ from qnapstats import QNAPStats
from requests.exceptions import ConnectTimeout
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import (
CONF_HOST,
CONF_PASSWORD,
@ -17,7 +17,6 @@ from homeassistant.const import (
CONF_USERNAME,
CONF_VERIFY_SSL,
)
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers import config_validation as cv
from .const import (
@ -42,7 +41,7 @@ DATA_SCHEMA = vol.Schema(
_LOGGER = logging.getLogger(__name__)
class QnapConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class QnapConfigFlow(ConfigFlow, domain=DOMAIN):
"""Qnap configuration flow."""
VERSION = 1
@ -50,7 +49,7 @@ class QnapConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user(
self,
user_input: dict[str, Any] | None = None,
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle a flow initialized by the user."""
errors = {}
if user_input is not None:

14
homeassistant/components/qnap_qsw/config_flow.py
View File

@ -8,10 +8,10 @@ from aioqsw.exceptions import LoginError, QswError
from aioqsw.localapi import ConnectionOptions, QnapQswApi
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.components import dhcp
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_PASSWORD, CONF_URL, CONF_USERNAME
from homeassistant.data_entry_flow import AbortFlow, FlowResult
from homeassistant.data_entry_flow import AbortFlow
from homeassistant.helpers import aiohttp_client
from homeassistant.helpers.device_registry import format_mac
@ -20,7 +20,7 @@ from .const import DOMAIN
_LOGGER = logging.getLogger(__name__)
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class QNapQSWConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle config flow for a QNAP QSW device."""
_discovered_mac: str | None = None
@ -28,7 +28,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the initial step."""
errors = {}
@ -71,7 +71,9 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
errors=errors,
)
async def async_step_dhcp(self, discovery_info: dhcp.DhcpServiceInfo) -> FlowResult:
async def async_step_dhcp(
self, discovery_info: dhcp.DhcpServiceInfo
) -> ConfigFlowResult:
"""Handle DHCP discovery."""
self._discovered_url = f"http://{discovery_info.ip}"
self._discovered_mac = discovery_info.macaddress
@ -97,7 +99,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_discovered_connection(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Confirm discovery."""
errors = {}
assert self._discovered_url is not None

5
homeassistant/components/rabbitair/config_flow.py
View File

@ -11,7 +11,6 @@ from homeassistant import config_entries
from homeassistant.components import zeroconf
from homeassistant.const import CONF_ACCESS_TOKEN, CONF_HOST, CONF_MAC
from homeassistant.core import HomeAssistant
from homeassistant.data_entry_flow import FlowResult
from homeassistant.exceptions import HomeAssistantError
from homeassistant.helpers import device_registry as dr
@ -58,7 +57,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> config_entries.ConfigFlowResult:
"""Handle the initial step."""
errors = {}
@ -100,7 +99,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_zeroconf(
self, discovery_info: zeroconf.ZeroconfServiceInfo
) -> FlowResult:
) -> config_entries.ConfigFlowResult:
"""Handle zeroconf discovery."""
mac = dr.format_mac(discovery_info.properties["id"])
await self.async_set_unique_id(mac)

27
homeassistant/components/rachio/config_flow.py
View File

@ -8,11 +8,16 @@ from rachiopy import Rachio
from requests.exceptions import ConnectTimeout
import voluptuous as vol
from homeassistant import config_entries, core, exceptions
from homeassistant.components import zeroconf
from homeassistant.config_entries import (
ConfigEntry,
ConfigFlow,
ConfigFlowResult,
OptionsFlow,
)
from homeassistant.const import CONF_API_KEY
from homeassistant.core import callback
from homeassistant.data_entry_flow import FlowResult
from homeassistant.core import HomeAssistant, callback
from homeassistant.exceptions import HomeAssistantError
from .const import (
CONF_MANUAL_RUN_MINS,
@ -28,7 +33,7 @@ _LOGGER = logging.getLogger(__name__)
DATA_SCHEMA = vol.Schema({vol.Required(CONF_API_KEY): str}, extra=vol.ALLOW_EXTRA)
async def validate_input(hass: core.HomeAssistant, data):
async def validate_input(hass: HomeAssistant, data):
"""Validate the user input allows us to connect.
Data has the keys from DATA_SCHEMA with values provided by the user.
@ -56,7 +61,7 @@ async def validate_input(hass: core.HomeAssistant, data):
return {"title": username}
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class RachioConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Rachio."""
VERSION = 1
@ -84,7 +89,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_homekit(
self, discovery_info: zeroconf.ZeroconfServiceInfo
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle HomeKit discovery."""
self._async_abort_entries_match()
await self.async_set_unique_id(
@ -96,16 +101,16 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
@staticmethod
@callback
def async_get_options_flow(
config_entry: config_entries.ConfigEntry,
config_entry: ConfigEntry,
) -> OptionsFlowHandler:
"""Get the options flow for this handler."""
return OptionsFlowHandler(config_entry)
class OptionsFlowHandler(config_entries.OptionsFlow):
class OptionsFlowHandler(OptionsFlow):
"""Handle a option flow for Rachio."""
def __init__(self, config_entry: config_entries.ConfigEntry) -> None:
def __init__(self, config_entry: ConfigEntry) -> None:
"""Initialize options flow."""
self.config_entry = config_entry
@ -127,9 +132,9 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
return self.async_show_form(step_id="init", data_schema=data_schema)
class CannotConnect(exceptions.HomeAssistantError):
class CannotConnect(HomeAssistantError):
"""Error to indicate we cannot connect."""
class InvalidAuth(exceptions.HomeAssistantError):
class InvalidAuth(HomeAssistantError):
"""Error to indicate there is invalid auth."""

9
homeassistant/components/radarr/config_flow.py
View File

@ -10,10 +10,9 @@ from aiopyarr.models.host_configuration import PyArrHostConfiguration
from aiopyarr.radarr_client import RadarrClient
import voluptuous as vol
from homeassistant.config_entries import ConfigEntry, ConfigFlow
from homeassistant.config_entries import ConfigEntry, ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_API_KEY, CONF_URL, CONF_VERIFY_SSL
from homeassistant.core import HomeAssistant
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers.aiohttp_client import async_get_clientsession
from .const import DEFAULT_NAME, DEFAULT_URL, DOMAIN
@ -28,7 +27,7 @@ class RadarrConfigFlow(ConfigFlow, domain=DOMAIN):
"""Initialize the flow."""
self.entry: ConfigEntry | None = None
async def async_step_reauth(self, _: Mapping[str, Any]) -> FlowResult:
async def async_step_reauth(self, _: Mapping[str, Any]) -> ConfigFlowResult:
"""Handle configuration by re-auth."""
self.entry = self.hass.config_entries.async_get_entry(self.context["entry_id"])
@ -36,7 +35,7 @@ class RadarrConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_reauth_confirm(
self, user_input: dict[str, str] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Confirm reauth dialog."""
if user_input is not None:
return await self.async_step_user()
@ -46,7 +45,7 @@ class RadarrConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle a flow initiated by the user."""
errors = {}

7
homeassistant/components/radio_browser/config_flow.py
View File

@ -3,8 +3,7 @@ from __future__ import annotations
from typing import Any
from homeassistant.config_entries import ConfigFlow
from homeassistant.data_entry_flow import FlowResult
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from .const import DOMAIN
@ -16,7 +15,7 @@ class RadioBrowserConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the initial step."""
if self._async_current_entries():
return self.async_abort(reason="single_instance_allowed")
@ -28,6 +27,6 @@ class RadioBrowserConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_onboarding(
self, data: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle a flow initialized by onboarding."""
return self.async_create_entry(title="Radio Browser", data={})

11
homeassistant/components/radiotherm/config_flow.py
View File

@ -8,11 +8,10 @@ from urllib.error import URLError
from radiotherm.validate import RadiothermTstatError
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.components import dhcp
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_HOST
from homeassistant.core import HomeAssistant
from homeassistant.data_entry_flow import FlowResult
from homeassistant.exceptions import HomeAssistantError
from .const import DOMAIN
@ -33,7 +32,7 @@ async def validate_connection(hass: HomeAssistant, host: str) -> RadioThermInitD
raise CannotConnect(f"Failed to connect to {host}: {ex}") from ex
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class RadioThermConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Radio Thermostat."""
VERSION = 1
@ -43,7 +42,9 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
self.discovered_ip: str | None = None
self.discovered_init_data: RadioThermInitData | None = None
async def async_step_dhcp(self, discovery_info: dhcp.DhcpServiceInfo) -> FlowResult:
async def async_step_dhcp(
self, discovery_info: dhcp.DhcpServiceInfo
) -> ConfigFlowResult:
"""Discover via DHCP."""
self._async_abort_entries_match({CONF_HOST: discovery_info.ip})
try:
@ -84,7 +85,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the initial step."""
errors = {}
if user_input is not None:

19
homeassistant/components/rainbird/config_flow.py
View File

@ -14,11 +14,14 @@ from pyrainbird.async_client import (
from pyrainbird.data import WifiParams
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.config_entries import ConfigEntry
from homeassistant.config_entries import (
ConfigEntry,
ConfigFlow,
ConfigFlowResult,
OptionsFlow,
)
from homeassistant.const import CONF_HOST, CONF_MAC, CONF_PASSWORD
from homeassistant.core import callback
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers import config_validation as cv, selector
from homeassistant.helpers.aiohttp_client import async_get_clientsession
from homeassistant.helpers.device_registry import format_mac
@ -53,7 +56,7 @@ class ConfigFlowError(Exception):
self.error_code = error_code
class RainbirdConfigFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
class RainbirdConfigFlowHandler(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Rain Bird."""
@staticmethod
@ -66,7 +69,7 @@ class RainbirdConfigFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Configure the Rain Bird device."""
error_code: str | None = None
if user_input:
@ -129,7 +132,7 @@ class RainbirdConfigFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
self,
data: dict[str, Any],
options: dict[str, Any],
) -> FlowResult:
) -> ConfigFlowResult:
"""Create the config entry."""
# The integration has historically used a serial number, but not all devices
# historically had a valid one. Now the mac address is used as a unique id
@ -156,7 +159,7 @@ class RainbirdConfigFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
)
class RainBirdOptionsFlowHandler(config_entries.OptionsFlow):
class RainBirdOptionsFlowHandler(OptionsFlow):
"""Handle a RainBird options flow."""
def __init__(self, config_entry: ConfigEntry) -> None:
@ -165,7 +168,7 @@ class RainBirdOptionsFlowHandler(config_entries.OptionsFlow):
async def async_step_init(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Manage the options."""
if user_input is not None:
return self.async_create_entry(data=user_input)

7
homeassistant/components/rainforest_eagle/config_flow.py
View File

@ -6,9 +6,8 @@ from typing import Any
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_HOST, CONF_TYPE
from homeassistant.data_entry_flow import FlowResult
from . import data
from .const import CONF_CLOUD_ID, CONF_HARDWARE_ADDRESS, CONF_INSTALL_CODE, DOMAIN
@ -31,14 +30,14 @@ def create_schema(user_input: dict[str, Any] | None) -> vol.Schema:
)
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class RainforestEagleConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Rainforest Eagle."""
VERSION = 1
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the initial step."""
if user_input is None:
return self.async_show_form(

13
homeassistant/components/rainforest_raven/config_flow.py
View File

@ -11,10 +11,9 @@ import serial.tools.list_ports
from serial.tools.list_ports_common import ListPortInfo
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.components import usb
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_DEVICE, CONF_MAC, CONF_NAME
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers.selector import (
SelectSelector,
SelectSelectorConfig,
@ -38,7 +37,7 @@ def _generate_unique_id(info: ListPortInfo | usb.UsbServiceInfo) -> str:
)
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class RainforestRavenConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Rainforest RAVEn devices."""
def __init__(self) -> None:
@ -66,7 +65,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_meters(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Connect to device and discover meters."""
errors: dict[str, str] = {}
if user_input is not None:
@ -98,7 +97,9 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
)
return self.async_show_form(step_id="meters", data_schema=schema, errors=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."""
device = discovery_info.device
dev_path = await self.hass.async_add_executor_job(usb.get_serial_by_id, device)
@ -114,7 +115,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle a flow initiated by the user."""
if self._async_in_progress():
return self.async_abort(reason="already_in_progress")

23
homeassistant/components/rainmachine/config_flow.py
View File

@ -8,12 +8,15 @@ from regenmaschine.controller import Controller
from regenmaschine.errors import RainMachineError
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.components import zeroconf
from homeassistant.config_entries import ConfigEntry
from homeassistant.config_entries import (
ConfigEntry,
ConfigFlow,
ConfigFlowResult,
OptionsFlow,
)
from homeassistant.const import CONF_IP_ADDRESS, CONF_PASSWORD, CONF_PORT, CONF_SSL
from homeassistant.core import HomeAssistant, callback
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers import aiohttp_client, config_validation as cv
from .const import (
@ -46,7 +49,7 @@ async def async_get_controller(
return get_client_controller(client)
class RainMachineFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
class RainMachineFlowHandler(ConfigFlow, domain=DOMAIN):
"""Handle a RainMachine config flow."""
VERSION = 2
@ -63,19 +66,19 @@ class RainMachineFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_homekit(
self, discovery_info: zeroconf.ZeroconfServiceInfo
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle a flow initialized by homekit discovery."""
return await self.async_step_homekit_zeroconf(discovery_info)
async def async_step_zeroconf(
self, discovery_info: zeroconf.ZeroconfServiceInfo
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle discovery via zeroconf."""
return await self.async_step_homekit_zeroconf(discovery_info)
async def async_step_homekit_zeroconf(
self, discovery_info: zeroconf.ZeroconfServiceInfo
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle discovery via zeroconf."""
ip_address = discovery_info.host
@ -117,7 +120,7 @@ class RainMachineFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the start of the config flow."""
errors = {}
if user_input:
@ -161,7 +164,7 @@ class RainMachineFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
)
class RainMachineOptionsFlowHandler(config_entries.OptionsFlow):
class RainMachineOptionsFlowHandler(OptionsFlow):
"""Handle a RainMachine options flow."""
def __init__(self, config_entry: ConfigEntry) -> None:
@ -170,7 +173,7 @@ class RainMachineOptionsFlowHandler(config_entries.OptionsFlow):
async def async_step_init(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Manage the options."""
if user_input is not None:
return self.async_create_entry(data=user_input)

9
homeassistant/components/rapt_ble/config_flow.py
View File

@ -10,9 +10,8 @@ from homeassistant.components.bluetooth import (
BluetoothServiceInfoBleak,
async_discovered_service_info,
)
from homeassistant.config_entries import ConfigFlow
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_ADDRESS
from homeassistant.data_entry_flow import FlowResult
from .const import DOMAIN
@ -30,7 +29,7 @@ class RAPTPillConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_bluetooth(
self, discovery_info: BluetoothServiceInfoBleak
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the bluetooth discovery step."""
await self.async_set_unique_id(discovery_info.address)
self._abort_if_unique_id_configured()
@ -43,7 +42,7 @@ class RAPTPillConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_bluetooth_confirm(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Confirm discovery."""
assert self._discovered_device is not None
device = self._discovered_device
@ -62,7 +61,7 @@ class RAPTPillConfigFlow(ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the user step to pick discovered device."""
if user_input is not None:
address = user_input[CONF_ADDRESS]

7
homeassistant/components/raspberry_pi/config_flow.py
View File

@ -3,8 +3,7 @@ from __future__ import annotations
from typing import Any
from homeassistant.config_entries import ConfigFlow
from homeassistant.data_entry_flow import FlowResult
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from .const import DOMAIN
@ -14,7 +13,9 @@ class RaspberryPiConfigFlow(ConfigFlow, domain=DOMAIN):
VERSION = 1
async def async_step_system(self, data: dict[str, Any] | None = None) -> FlowResult:
async def async_step_system(
self, data: dict[str, Any] | None = None
) -> ConfigFlowResult:
"""Handle the initial step."""
if self._async_current_entries():
return self.async_abort(reason="single_instance_allowed")

5
homeassistant/components/rdw/config_flow.py
View File

@ -6,8 +6,7 @@ from typing import Any
from vehicle import RDW, RDWError, RDWUnknownLicensePlateError
import voluptuous as vol
from homeassistant.config_entries import ConfigFlow
from homeassistant.data_entry_flow import FlowResult
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.helpers.aiohttp_client import async_get_clientsession
from .const import CONF_LICENSE_PLATE, DOMAIN
@ -20,7 +19,7 @@ class RDWFlowHandler(ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle a flow initialized by the user."""
errors = {}

22
homeassistant/components/recollect_waste/config_flow.py
View File

@ -7,10 +7,14 @@ from aiorecollect.client import Client
from aiorecollect.errors import RecollectError
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.config_entries import (
ConfigEntry,
ConfigFlow,
ConfigFlowResult,
OptionsFlow,
)
from homeassistant.const import CONF_FRIENDLY_NAME
from homeassistant.core import callback
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers import aiohttp_client
from .const import CONF_PLACE_ID, CONF_SERVICE_ID, DOMAIN, LOGGER
@ -20,7 +24,7 @@ DATA_SCHEMA = vol.Schema(
)
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class RecollectWasteConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for ReCollect Waste."""
VERSION = 2
@ -28,14 +32,14 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
@staticmethod
@callback
def async_get_options_flow(
config_entry: config_entries.ConfigEntry,
) -> config_entries.OptionsFlow:
config_entry: ConfigEntry,
) -> OptionsFlow:
"""Define the config flow to handle options."""
return RecollectWasteOptionsFlowHandler(config_entry)
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle configuration via the UI."""
if user_input is None:
return self.async_show_form(
@ -71,16 +75,16 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
)
class RecollectWasteOptionsFlowHandler(config_entries.OptionsFlow):
class RecollectWasteOptionsFlowHandler(OptionsFlow):
"""Handle a Recollect Waste options flow."""
def __init__(self, entry: config_entries.ConfigEntry) -> None:
def __init__(self, entry: ConfigEntry) -> None:
"""Initialize."""
self._entry = entry
async def async_step_init(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Manage the options."""
if user_input is not None:
return self.async_create_entry(title="", data=user_input)

19
homeassistant/components/renault/config_flow.py
View File

@ -7,15 +7,14 @@ from typing import TYPE_CHECKING, Any
from renault_api.const import AVAILABLE_LOCALES
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
from homeassistant.data_entry_flow import FlowResult
from .const import CONF_KAMEREON_ACCOUNT_ID, CONF_LOCALE, DOMAIN
from .renault_hub import RenaultHub
class RenaultFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
class RenaultFlowHandler(ConfigFlow, domain=DOMAIN):
"""Handle a Renault config flow."""
VERSION = 1
@ -28,7 +27,7 @@ class RenaultFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle a Renault config flow start.
Ask the user for API keys.
@ -45,7 +44,7 @@ class RenaultFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
return await self.async_step_kamereon()
return self._show_user_form()
def _show_user_form(self, errors: dict[str, Any] | None = None) -> FlowResult:
def _show_user_form(self, errors: dict[str, Any] | None = None) -> ConfigFlowResult:
"""Show the API keys form."""
return self.async_show_form(
step_id="user",
@ -61,7 +60,7 @@ class RenaultFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_kamereon(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Select Kamereon account."""
if user_input:
await self.async_set_unique_id(user_input[CONF_KAMEREON_ACCOUNT_ID])
@ -93,14 +92,16 @@ class RenaultFlowHandler(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:
"""Perform reauth upon an API authentication error."""
self._original_data = entry_data
return await self.async_step_reauth_confirm()
async def async_step_reauth_confirm(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Dialog that informs the user that reauth is required."""
if not user_input:
return self._show_reauth_confirm_form()
@ -128,7 +129,7 @@ class RenaultFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
def _show_reauth_confirm_form(
self, errors: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Show the API keys form."""
if TYPE_CHECKING:
assert self._original_data

7
homeassistant/components/renson/config_flow.py
View File

@ -7,10 +7,9 @@ from typing import Any
from renson_endura_delta import renson
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_HOST
from homeassistant.core import HomeAssistant
from homeassistant.data_entry_flow import FlowResult
from homeassistant.exceptions import HomeAssistantError
from .const import DOMAIN
@ -24,7 +23,7 @@ STEP_USER_DATA_SCHEMA = vol.Schema(
)
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class RensonConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Renson."""
VERSION = 1
@ -42,7 +41,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the initial step."""
if user_input is None:
return self.async_show_form(

29
homeassistant/components/reolink/config_flow.py
View File

@ -8,8 +8,13 @@ from typing import Any
from reolink_aio.exceptions import ApiError, CredentialsInvalidError, ReolinkError
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.components import dhcp
from homeassistant.config_entries import (
ConfigEntry,
ConfigFlow,
ConfigFlowResult,
OptionsFlow,
)
from homeassistant.const import (
CONF_HOST,
CONF_PASSWORD,
@ -18,7 +23,7 @@ from homeassistant.const import (
CONF_USERNAME,
)
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.device_registry import format_mac
@ -33,7 +38,7 @@ DEFAULT_PROTOCOL = "rtsp"
DEFAULT_OPTIONS = {CONF_PROTOCOL: DEFAULT_PROTOCOL}
class ReolinkOptionsFlowHandler(config_entries.OptionsFlow):
class ReolinkOptionsFlowHandler(OptionsFlow):
"""Handle Reolink options."""
def __init__(self, config_entry):
@ -42,7 +47,7 @@ class ReolinkOptionsFlowHandler(config_entries.OptionsFlow):
async def async_step_init(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Manage the Reolink options."""
if user_input is not None:
return self.async_create_entry(data=user_input)
@ -60,7 +65,7 @@ class ReolinkOptionsFlowHandler(config_entries.OptionsFlow):
)
class ReolinkFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
class ReolinkFlowHandler(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Reolink device."""
VERSION = 1
@ -75,12 +80,14 @@ class ReolinkFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
@staticmethod
@callback
def async_get_options_flow(
config_entry: config_entries.ConfigEntry,
config_entry: ConfigEntry,
) -> ReolinkOptionsFlowHandler:
"""Options callback for Reolink."""
return ReolinkOptionsFlowHandler(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 no admin privileges."""
self._host = entry_data[CONF_HOST]
self._username = entry_data[CONF_USERNAME]
@ -94,13 +101,15 @@ class ReolinkFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_reauth_confirm(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Dialog that informs the user that reauth is required."""
if user_input is not None:
return await self.async_step_user()
return self.async_show_form(step_id="reauth_confirm")
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."""
mac_address = format_mac(discovery_info.macaddress)
existing_entry = await self.async_set_unique_id(mac_address)
@ -157,7 +166,7 @@ class ReolinkFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the initial step."""
errors = {}
placeholders = {

2
homeassistant/components/repairs/models.py
View File

@ -7,7 +7,7 @@ from homeassistant import data_entry_flow
from homeassistant.core import HomeAssistant
class RepairsFlow(data_entry_flow.BaseFlowHandler[data_entry_flow.FlowResult]):
class RepairsFlow(data_entry_flow.FlowHandler):
"""Handle a flow for fixing an issue."""
_flow_result = data_entry_flow.FlowResult

31
homeassistant/components/rfxtrx/config_flow.py
View File

@ -13,8 +13,12 @@ import serial
import serial.tools.list_ports
import voluptuous as vol
from homeassistant import config_entries, data_entry_flow, exceptions
from homeassistant.config_entries import ConfigEntry
from homeassistant.config_entries import (
ConfigEntry,
ConfigFlow,
ConfigFlowResult,
OptionsFlow,
)
from homeassistant.const import (
CONF_COMMAND_OFF,
CONF_COMMAND_ON,
@ -26,6 +30,7 @@ from homeassistant.const import (
CONF_TYPE,
)
from homeassistant.core import State, callback
from homeassistant.exceptions import HomeAssistantError
from homeassistant.helpers import (
config_validation as cv,
device_registry as dr,
@ -74,7 +79,7 @@ def none_or_int(value: str | None, base: int) -> int | None:
return int(value, base)
class OptionsFlow(config_entries.OptionsFlow):
class RfxtrxOptionsFlow(OptionsFlow):
"""Handle Rfxtrx options."""
_device_registry: dr.DeviceRegistry
@ -91,13 +96,13 @@ class OptionsFlow(config_entries.OptionsFlow):
async def async_step_init(
self, user_input: dict[str, Any] | None = None
) -> data_entry_flow.FlowResult:
) -> ConfigFlowResult:
"""Manage the options."""
return await self.async_step_prompt_options()
async def async_step_prompt_options(
self, user_input: dict[str, Any] | None = None
) -> data_entry_flow.FlowResult:
) -> ConfigFlowResult:
"""Prompt for options."""
errors = {}
@ -171,7 +176,7 @@ class OptionsFlow(config_entries.OptionsFlow):
async def async_step_set_device_options(
self, user_input: dict[str, Any] | None = None
) -> data_entry_flow.FlowResult:
) -> ConfigFlowResult:
"""Manage device options."""
errors = {}
assert self._selected_device_object
@ -489,14 +494,14 @@ class OptionsFlow(config_entries.OptionsFlow):
)
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class RfxtrxConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for RFXCOM RFXtrx."""
VERSION = 1
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> data_entry_flow.FlowResult:
) -> ConfigFlowResult:
"""Step when user initializes a integration."""
await self.async_set_unique_id(DOMAIN)
self._abort_if_unique_id_configured()
@ -515,7 +520,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_setup_network(
self, user_input: dict[str, Any] | None = None
) -> data_entry_flow.FlowResult:
) -> ConfigFlowResult:
"""Step when setting up network configuration."""
errors: dict[str, str] = {}
@ -542,7 +547,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_setup_serial(
self, user_input: dict[str, Any] | None = None
) -> data_entry_flow.FlowResult:
) -> ConfigFlowResult:
"""Step when setting up serial configuration."""
errors: dict[str, str] = {}
@ -581,7 +586,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_setup_serial_manual_path(
self, user_input: dict[str, Any] | None = None
) -> data_entry_flow.FlowResult:
) -> ConfigFlowResult:
"""Select path manually."""
errors: dict[str, str] = {}
@ -628,7 +633,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
@callback
def async_get_options_flow(config_entry: ConfigEntry) -> OptionsFlow:
"""Get the options flow for this handler."""
return OptionsFlow(config_entry)
return RfxtrxOptionsFlow(config_entry)
def _test_transport(host: str | None, port: int | None, device: str | None) -> bool:
@ -658,5 +663,5 @@ def get_serial_by_id(dev_path: str) -> str:
return dev_path
class CannotConnect(exceptions.HomeAssistantError):
class CannotConnect(HomeAssistantError):
"""Error to indicate we cannot connect."""

7
homeassistant/components/rhasspy/config_flow.py
View File

@ -5,20 +5,19 @@ from typing import Any
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.data_entry_flow import FlowResult
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from .const import DOMAIN
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class RhasspyConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Rhasspy."""
VERSION = 1
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the initial step."""
if self._async_current_entries():
return self.async_abort(reason="single_instance_allowed")

17
homeassistant/components/ridwell/config_flow.py
View File

@ -8,9 +8,8 @@ from aioridwell import async_get_client
from aioridwell.errors import InvalidCredentialsError, RidwellError
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
from homeassistant.data_entry_flow import FlowResult
from homeassistant.helpers import aiohttp_client, config_validation as cv
from .const import DOMAIN, LOGGER
@ -29,8 +28,8 @@ STEP_USER_DATA_SCHEMA = vol.Schema(
)
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
"""Handle a config flow for WattTime."""
class RidwellConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Ridwell."""
VERSION = 2
@ -41,7 +40,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def _async_validate(
self, error_step_id: str, error_schema: vol.Schema
) -> FlowResult:
) -> ConfigFlowResult:
"""Validate input credentials and proceed accordingly."""
errors = {}
session = aiohttp_client.async_get_clientsession(self.hass)
@ -81,14 +80,16 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
data={CONF_USERNAME: self._username, CONF_PASSWORD: self._password},
)
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."""
self._username = entry_data[CONF_USERNAME]
return await self.async_step_reauth_confirm()
async def async_step_reauth_confirm(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle re-auth completion."""
if not user_input:
return self.async_show_form(
@ -105,7 +106,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Handle the initial step."""
if not user_input:
return self.async_show_form(

20
homeassistant/components/ring/config_flow.py
View File

@ -6,8 +6,7 @@ from typing import Any
import ring_doorbell
import voluptuous as vol
from homeassistant import config_entries, core, exceptions
from homeassistant.config_entries import ConfigEntry
from homeassistant.config_entries import ConfigEntry, ConfigFlow, ConfigFlowResult
from homeassistant.const import (
APPLICATION_NAME,
CONF_PASSWORD,
@ -15,7 +14,8 @@ from homeassistant.const import (
CONF_USERNAME,
__version__ as ha_version,
)
from homeassistant.data_entry_flow import FlowResult
from homeassistant.core import HomeAssistant
from homeassistant.exceptions import HomeAssistantError
from .const import CONF_2FA, DOMAIN
@ -27,7 +27,7 @@ STEP_USER_DATA_SCHEMA = vol.Schema(
STEP_REAUTH_DATA_SCHEMA = vol.Schema({vol.Required(CONF_PASSWORD): str})
async def validate_input(hass: core.HomeAssistant, data):
async def validate_input(hass: HomeAssistant, data):
"""Validate the user input allows us to connect."""
auth = ring_doorbell.Auth(f"{APPLICATION_NAME}/{ha_version}")
@ -47,7 +47,7 @@ async def validate_input(hass: core.HomeAssistant, data):
return token
class RingConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
class RingConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Ring."""
VERSION = 1
@ -96,7 +96,9 @@ class RingConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
data_schema=vol.Schema({vol.Required(CONF_2FA): str}),
)
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 upon an API authentication error."""
self.reauth_entry = self.hass.config_entries.async_get_entry(
self.context["entry_id"]
@ -105,7 +107,7 @@ class RingConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
async def async_step_reauth_confirm(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
) -> ConfigFlowResult:
"""Dialog that informs the user that reauth is required."""
errors = {}
assert self.reauth_entry is not None
@ -143,9 +145,9 @@ class RingConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
)
class Require2FA(exceptions.HomeAssistantError):
class Require2FA(HomeAssistantError):
"""Error to indicate we require 2FA."""
class InvalidAuth(exceptions.HomeAssistantError):
class InvalidAuth(HomeAssistantError):
"""Error to indicate there is invalid auth."""

Some files were not shown because too many files have changed in this diff Show More