Remove deprecated YAML import from Satel Integra (#164469)

homeassistant/components/satel_integra/__init__.py

@@ -2,35 +2,17 @@
 
 import logging
 
-import voluptuous as vol
+from homeassistant.const import Platform
-
+from homeassistant.core import HomeAssistant, callback
-from homeassistant.config_entries import SOURCE_IMPORT
+from homeassistant.helpers import config_validation as cv, device_registry as dr
-from homeassistant.const import CONF_CODE, CONF_HOST, CONF_NAME, CONF_PORT, Platform
-from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN, HomeAssistant, callback
-from homeassistant.data_entry_flow import FlowResultType
-from homeassistant.helpers import (
-    config_validation as cv,
-    device_registry as dr,
-    issue_registry as ir,
-)
 from homeassistant.helpers.entity_registry import RegistryEntry, async_migrate_entries
-from homeassistant.helpers.typing import ConfigType
 
 from .client import SatelClient
 from .const import (
-    CONF_ARM_HOME_MODE,
-    CONF_DEVICE_PARTITIONS,
     CONF_OUTPUT_NUMBER,
-    CONF_OUTPUTS,
     CONF_PARTITION_NUMBER,
     CONF_SWITCHABLE_OUTPUT_NUMBER,
-    CONF_SWITCHABLE_OUTPUTS,
     CONF_ZONE_NUMBER,
-    CONF_ZONE_TYPE,
-    CONF_ZONES,
-    DEFAULT_CONF_ARM_HOME_MODE,
-    DEFAULT_PORT,
-    DEFAULT_ZONE_TYPE,
     DOMAIN,
     SUBENTRY_TYPE_OUTPUT,
     SUBENTRY_TYPE_PARTITION,
@@ -49,104 +31,7 @@ _LOGGER = logging.getLogger(__name__)
 
 PLATFORMS = [Platform.ALARM_CONTROL_PANEL, Platform.BINARY_SENSOR, Platform.SWITCH]
 
-
+CONFIG_SCHEMA = cv.removed(DOMAIN, raise_if_present=False)
-ZONE_SCHEMA = vol.Schema(
-    {
-        vol.Required(CONF_NAME): cv.string,
-        vol.Optional(CONF_ZONE_TYPE, default=DEFAULT_ZONE_TYPE): cv.string,
-    }
-)
-EDITABLE_OUTPUT_SCHEMA = vol.Schema({vol.Required(CONF_NAME): cv.string})
-PARTITION_SCHEMA = vol.Schema(
-    {
-        vol.Required(CONF_NAME): cv.string,
-        vol.Optional(CONF_ARM_HOME_MODE, default=DEFAULT_CONF_ARM_HOME_MODE): vol.In(
-            [1, 2, 3]
-        ),
-    }
-)
-
-
-def is_alarm_code_necessary(value):
-    """Check if alarm code must be configured."""
-    if value.get(CONF_SWITCHABLE_OUTPUTS) and CONF_CODE not in value:
-        raise vol.Invalid("You need to specify alarm code to use switchable_outputs")
-
-    return value
-
-
-CONFIG_SCHEMA = vol.Schema(
-    {
-        DOMAIN: vol.All(
-            {
-                vol.Required(CONF_HOST): cv.string,
-                vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
-                vol.Optional(CONF_CODE): cv.string,
-                vol.Optional(CONF_DEVICE_PARTITIONS, default={}): {
-                    vol.Coerce(int): PARTITION_SCHEMA
-                },
-                vol.Optional(CONF_ZONES, default={}): {vol.Coerce(int): ZONE_SCHEMA},
-                vol.Optional(CONF_OUTPUTS, default={}): {vol.Coerce(int): ZONE_SCHEMA},
-                vol.Optional(CONF_SWITCHABLE_OUTPUTS, default={}): {
-                    vol.Coerce(int): EDITABLE_OUTPUT_SCHEMA
-                },
-            },
-            is_alarm_code_necessary,
-        )
-    },
-    extra=vol.ALLOW_EXTRA,
-)
-
-
-async def async_setup(hass: HomeAssistant, hass_config: ConfigType) -> bool:
-    """Set up  Satel Integra from YAML."""
-
-    if config := hass_config.get(DOMAIN):
-        hass.async_create_task(_async_import(hass, config))
-
-    return True
-
-
-async def _async_import(hass: HomeAssistant, config: ConfigType) -> None:
-    """Process YAML import."""
-
-    if not hass.config_entries.async_entries(DOMAIN):
-        # Start import flow
-        result = await hass.config_entries.flow.async_init(
-            DOMAIN, context={"source": SOURCE_IMPORT}, data=config
-        )
-
-        if result.get("type") == FlowResultType.ABORT:
-            ir.async_create_issue(
-                hass,
-                DOMAIN,
-                "deprecated_yaml_import_issue_cannot_connect",
-                breaks_in_ha_version="2026.4.0",
-                is_fixable=False,
-                issue_domain=DOMAIN,
-                severity=ir.IssueSeverity.WARNING,
-                translation_key="deprecated_yaml_import_issue_cannot_connect",
-                translation_placeholders={
-                    "domain": DOMAIN,
-                    "integration_title": "Satel Integra",
-                },
-            )
-            return
-
-    ir.async_create_issue(
-        hass,
-        HOMEASSISTANT_DOMAIN,
-        f"deprecated_yaml_{DOMAIN}",
-        breaks_in_ha_version="2026.4.0",
-        is_fixable=False,
-        issue_domain=DOMAIN,
-        severity=ir.IssueSeverity.WARNING,
-        translation_key="deprecated_yaml",
-        translation_placeholders={
-            "domain": DOMAIN,
-            "integration_title": "Satel Integra",
-        },
-    )
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: SatelConfigEntry) -> bool:

homeassistant/components/satel_integra/config_flow.py

@@ -13,7 +13,6 @@ from homeassistant.config_entries import (
     ConfigEntry,
     ConfigFlow,
     ConfigFlowResult,
-    ConfigSubentryData,
     ConfigSubentryFlow,
     OptionsFlow,
     SubentryFlowResult,
@@ -24,15 +23,11 @@ from homeassistant.helpers import config_validation as cv, selector
 
 from .const import (
     CONF_ARM_HOME_MODE,
-    CONF_DEVICE_PARTITIONS,
     CONF_OUTPUT_NUMBER,
-    CONF_OUTPUTS,
     CONF_PARTITION_NUMBER,
     CONF_SWITCHABLE_OUTPUT_NUMBER,
-    CONF_SWITCHABLE_OUTPUTS,
     CONF_ZONE_NUMBER,
     CONF_ZONE_TYPE,
-    CONF_ZONES,
     DEFAULT_CONF_ARM_HOME_MODE,
     DEFAULT_PORT,
     DOMAIN,
@@ -53,6 +48,7 @@ CONNECTION_SCHEMA = vol.Schema(
     }
 )
 
+
 CODE_SCHEMA = vol.Schema(
     {
         vol.Optional(CONF_CODE): cv.string,
@@ -143,97 +139,6 @@ class SatelConfigFlow(ConfigFlow, domain=DOMAIN):
             step_id="user", data_schema=CONNECTION_SCHEMA, errors=errors
         )
 
-    async def async_step_import(
-        self, import_config: dict[str, Any]
-    ) -> ConfigFlowResult:
-        """Handle a flow initialized by import."""
-
-        valid = await self.test_connection(
-            import_config[CONF_HOST], import_config.get(CONF_PORT, DEFAULT_PORT)
-        )
-
-        if valid:
-            subentries: list[ConfigSubentryData] = []
-
-            for partition_number, partition_data in import_config.get(
-                CONF_DEVICE_PARTITIONS, {}
-            ).items():
-                subentries.append(
-                    {
-                        "subentry_type": SUBENTRY_TYPE_PARTITION,
-                        "title": f"{partition_data[CONF_NAME]} ({partition_number})",
-                        "unique_id": f"{SUBENTRY_TYPE_PARTITION}_{partition_number}",
-                        "data": {
-                            CONF_NAME: partition_data[CONF_NAME],
-                            CONF_ARM_HOME_MODE: partition_data.get(
-                                CONF_ARM_HOME_MODE, DEFAULT_CONF_ARM_HOME_MODE
-                            ),
-                            CONF_PARTITION_NUMBER: partition_number,
-                        },
-                    }
-                )
-
-            for zone_number, zone_data in import_config.get(CONF_ZONES, {}).items():
-                subentries.append(
-                    {
-                        "subentry_type": SUBENTRY_TYPE_ZONE,
-                        "title": f"{zone_data[CONF_NAME]} ({zone_number})",
-                        "unique_id": f"{SUBENTRY_TYPE_ZONE}_{zone_number}",
-                        "data": {
-                            CONF_NAME: zone_data[CONF_NAME],
-                            CONF_ZONE_NUMBER: zone_number,
-                            CONF_ZONE_TYPE: zone_data.get(
-                                CONF_ZONE_TYPE, BinarySensorDeviceClass.MOTION
-                            ),
-                        },
-                    }
-                )
-
-            for output_number, output_data in import_config.get(
-                CONF_OUTPUTS, {}
-            ).items():
-                subentries.append(
-                    {
-                        "subentry_type": SUBENTRY_TYPE_OUTPUT,
-                        "title": f"{output_data[CONF_NAME]} ({output_number})",
-                        "unique_id": f"{SUBENTRY_TYPE_OUTPUT}_{output_number}",
-                        "data": {
-                            CONF_NAME: output_data[CONF_NAME],
-                            CONF_OUTPUT_NUMBER: output_number,
-                            CONF_ZONE_TYPE: output_data.get(
-                                CONF_ZONE_TYPE, BinarySensorDeviceClass.MOTION
-                            ),
-                        },
-                    }
-                )
-
-            for switchable_output_number, switchable_output_data in import_config.get(
-                CONF_SWITCHABLE_OUTPUTS, {}
-            ).items():
-                subentries.append(
-                    {
-                        "subentry_type": SUBENTRY_TYPE_SWITCHABLE_OUTPUT,
-                        "title": f"{switchable_output_data[CONF_NAME]} ({switchable_output_number})",
-                        "unique_id": f"{SUBENTRY_TYPE_SWITCHABLE_OUTPUT}_{switchable_output_number}",
-                        "data": {
-                            CONF_NAME: switchable_output_data[CONF_NAME],
-                            CONF_SWITCHABLE_OUTPUT_NUMBER: switchable_output_number,
-                        },
-                    }
-                )
-
-            return self.async_create_entry(
-                title=import_config[CONF_HOST],
-                data={
-                    CONF_HOST: import_config[CONF_HOST],
-                    CONF_PORT: import_config.get(CONF_PORT, DEFAULT_PORT),
-                },
-                options={CONF_CODE: import_config.get(CONF_CODE)},
-                subentries=subentries,
-            )
-
-        return self.async_abort(reason="cannot_connect")
-
     async def test_connection(self, host: str, port: int) -> bool:
         """Test a connection to the Satel alarm."""
         controller = AsyncSatel(host, port, self.hass.loop)

homeassistant/components/satel_integra/const.py

@@ -2,7 +2,6 @@
 
 DEFAULT_CONF_ARM_HOME_MODE = 1
 DEFAULT_PORT = 7094
-DEFAULT_ZONE_TYPE = "motion"
 
 DOMAIN = "satel_integra"
 
@@ -16,11 +15,7 @@ CONF_ZONE_NUMBER = "zone_number"
 CONF_OUTPUT_NUMBER = "output_number"
 CONF_SWITCHABLE_OUTPUT_NUMBER = "switchable_output_number"
 
-CONF_DEVICE_PARTITIONS = "partitions"
 CONF_ARM_HOME_MODE = "arm_home_mode"
 CONF_ZONE_TYPE = "type"
-CONF_ZONES = "zones"
-CONF_OUTPUTS = "outputs"
-CONF_SWITCHABLE_OUTPUTS = "switchable_outputs"
 
 ZONES = "zones"

homeassistant/components/satel_integra/strings.json

@@ -167,12 +167,6 @@
       "message": "Cannot control switchable outputs because no user code is configured for this Satel Integra entry. Configure a code in the integration options to enable output control."
     }
   },
-  "issues": {
-    "deprecated_yaml_import_issue_cannot_connect": {
-      "description": "Configuring {integration_title} using YAML is being removed but there was an connection error importing your existing configuration.\n\nEnsure connection to {integration_title} works and restart Home Assistant to try again or remove the `{domain}` YAML configuration from your configuration.yaml file and add the {integration_title} integration manually.",
-      "title": "YAML import failed due to a connection error"
-    }
-  },
   "options": {
     "step": {
       "init": {

tests/components/satel_integra/__init__.py

@@ -6,19 +6,19 @@ from unittest.mock import AsyncMock
 import pytest
 
 from homeassistant.components.binary_sensor import BinarySensorDeviceClass
-from homeassistant.components.satel_integra import (
+from homeassistant.components.satel_integra.const import (
     CONF_ARM_HOME_MODE,
     CONF_OUTPUT_NUMBER,
     CONF_PARTITION_NUMBER,
     CONF_SWITCHABLE_OUTPUT_NUMBER,
     CONF_ZONE_NUMBER,
     CONF_ZONE_TYPE,
+    DEFAULT_PORT,
     SUBENTRY_TYPE_OUTPUT,
     SUBENTRY_TYPE_PARTITION,
     SUBENTRY_TYPE_SWITCHABLE_OUTPUT,
     SUBENTRY_TYPE_ZONE,
 )
-from homeassistant.components.satel_integra.const import DEFAULT_PORT
 from homeassistant.config_entries import ConfigSubentry
 from homeassistant.const import CONF_CODE, CONF_HOST, CONF_NAME, CONF_PORT
 from homeassistant.core import HomeAssistant

tests/components/satel_integra/test_config_flow.py

@@ -8,24 +8,15 @@ import pytest
 from homeassistant.components.binary_sensor import BinarySensorDeviceClass
 from homeassistant.components.satel_integra.const import (
     CONF_ARM_HOME_MODE,
-    CONF_DEVICE_PARTITIONS,
     CONF_OUTPUT_NUMBER,
-    CONF_OUTPUTS,
     CONF_PARTITION_NUMBER,
     CONF_SWITCHABLE_OUTPUT_NUMBER,
-    CONF_SWITCHABLE_OUTPUTS,
     CONF_ZONE_NUMBER,
     CONF_ZONE_TYPE,
-    CONF_ZONES,
     DEFAULT_PORT,
     DOMAIN,
 )
-from homeassistant.config_entries import (
+from homeassistant.config_entries import SOURCE_RECONFIGURE, SOURCE_USER, ConfigSubentry
-    SOURCE_IMPORT,
-    SOURCE_RECONFIGURE,
-    SOURCE_USER,
-    ConfigSubentry,
-)
 from homeassistant.const import CONF_CODE, CONF_HOST, CONF_NAME, CONF_PORT
 from homeassistant.core import HomeAssistant
 from homeassistant.data_entry_flow import FlowResultType
@@ -118,75 +109,6 @@ async def test_setup_connection_failed(
     assert len(mock_setup_entry.mock_calls) == 1
 
 
-@pytest.mark.parametrize(
-    ("import_input", "entry_data", "entry_options"),
-    [
-        (
-            {
-                CONF_HOST: MOCK_CONFIG_DATA[CONF_HOST],
-                CONF_PORT: MOCK_CONFIG_DATA[CONF_PORT],
-                CONF_CODE: MOCK_CONFIG_OPTIONS[CONF_CODE],
-                CONF_DEVICE_PARTITIONS: {
-                    "1": {CONF_NAME: "Partition Import 1", CONF_ARM_HOME_MODE: 1}
-                },
-                CONF_ZONES: {
-                    "1": {CONF_NAME: "Zone Import 1", CONF_ZONE_TYPE: "motion"},
-                    "2": {CONF_NAME: "Zone Import 2", CONF_ZONE_TYPE: "door"},
-                },
-                CONF_OUTPUTS: {
-                    "1": {CONF_NAME: "Output Import 1", CONF_ZONE_TYPE: "light"},
-                    "2": {CONF_NAME: "Output Import 2", CONF_ZONE_TYPE: "safety"},
-                },
-                CONF_SWITCHABLE_OUTPUTS: {
-                    "1": {CONF_NAME: "Switchable output Import 1"},
-                    "2": {CONF_NAME: "Switchable output Import 2"},
-                },
-            },
-            MOCK_CONFIG_DATA,
-            MOCK_CONFIG_OPTIONS,
-        )
-    ],
-)
-async def test_import_flow(
-    hass: HomeAssistant,
-    mock_satel: AsyncMock,
-    mock_setup_entry: AsyncMock,
-    import_input: dict[str, Any],
-    entry_data: dict[str, Any],
-    entry_options: dict[str, Any],
-) -> None:
-    """Test the import flow."""
-
-    result = await hass.config_entries.flow.async_init(
-        DOMAIN, context={"source": SOURCE_IMPORT}, data=import_input
-    )
-    assert result["type"] is FlowResultType.CREATE_ENTRY
-    assert result["title"] == MOCK_CONFIG_DATA[CONF_HOST]
-    assert result["data"] == entry_data
-    assert result["options"] == entry_options
-
-    assert len(result["subentries"]) == 7
-
-    assert len(mock_setup_entry.mock_calls) == 1
-
-
-async def test_import_flow_connection_failure(
-    hass: HomeAssistant, mock_satel: AsyncMock
-) -> None:
-    """Test the import flow."""
-
-    mock_satel.connect.return_value = False
-
-    result = await hass.config_entries.flow.async_init(
-        DOMAIN,
-        context={"source": SOURCE_IMPORT},
-        data=MOCK_CONFIG_DATA,
-    )
-
-    assert result["type"] is FlowResultType.ABORT
-    assert result["reason"] == "cannot_connect"
-
-
 @pytest.mark.parametrize(
     ("user_input", "entry_options"),
     [