Deprecate min_max and migrate to group sensor

homeassistant/components/group/__init__.py

@@ -47,7 +47,9 @@
     ATTR_OBJECT_ID,
     ATTR_ORDER,
     ATTR_REMOVE_ENTITIES,
+    CONF_GROUP_TYPE,
     CONF_HIDE_MEMBERS,
+    CONF_IGNORE_NON_NUMERIC,
     DATA_COMPONENT,
     DOMAIN,
     GROUP_ORDER,

homeassistant/components/group/config_flow.py

@@ -24,7 +24,7 @@
 
 from .binary_sensor import CONF_ALL, async_create_preview_binary_sensor
 from .button import async_create_preview_button
-from .const import CONF_HIDE_MEMBERS, CONF_IGNORE_NON_NUMERIC, DOMAIN
+from .const import CONF_GROUP_TYPE, CONF_HIDE_MEMBERS, CONF_IGNORE_NON_NUMERIC, DOMAIN
 from .cover import async_create_preview_cover
 from .entity import GroupEntity
 from .event import async_create_preview_event
@@ -180,7 +180,7 @@ async def light_switch_options_schema(
 
 async def choose_options_step(options: dict[str, Any]) -> str:
     """Return next step_id for options flow according to group_type."""
-    return cast(str, options["group_type"])
+    return cast(str, options[CONF_GROUP_TYPE])
 
 
 def set_group_type(
@@ -194,7 +194,7 @@ async def _set_group_type(
         handler: SchemaCommonFlowHandler, user_input: dict[str, Any]
     ) -> dict[str, Any]:
         """Add group type to user input."""
-        return {"group_type": group_type, **user_input}
+        return {CONF_GROUP_TYPE: group_type, **user_input}
 
     return _set_group_type
 
@@ -430,7 +430,7 @@ def ws_start_preview(
         config_entry = hass.config_entries.async_get_entry(config_entry_id)
         if not config_entry:
             raise HomeAssistantError
-        group_type = config_entry.options["group_type"]
+        group_type = config_entry.options[CONF_GROUP_TYPE]
         name = config_entry.options["name"]
         validated = PREVIEW_OPTIONS_SCHEMA[group_type](msg["user_input"])
         entity_registry = er.async_get(hass)

homeassistant/components/group/const.py

@@ -14,6 +14,7 @@
 
 CONF_HIDE_MEMBERS = "hide_members"
 CONF_IGNORE_NON_NUMERIC = "ignore_non_numeric"
+CONF_GROUP_TYPE = "group_type"
 
 DOMAIN = "group"
 DATA_COMPONENT: HassKey[EntityComponent[Group]] = HassKey(DOMAIN)

homeassistant/components/min_max/__init__.py

@@ -3,12 +3,26 @@
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
+from homeassistant.helpers.issue_registry import IssueSeverity, async_create_issue
+
+from .const import DOMAIN
 
 PLATFORMS = [Platform.SENSOR]
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up Min/Max from a config entry."""
+    async_create_issue(
+        hass,
+        DOMAIN,
+        f"migrate_to_group_sensor-{entry.entry_id}",
+        breaks_in_ha_version="2026.12.0",
+        is_fixable=True,
+        is_persistent=False,
+        severity=IssueSeverity.WARNING,
+        translation_key="migrate_to_group_sensor",
+        data={"entry_id": entry.entry_id},
+    )
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
     return True

homeassistant/components/min_max/config_flow.py

@@ -11,8 +11,10 @@
 from homeassistant.components.number import DOMAIN as NUMBER_DOMAIN
 from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN
 from homeassistant.const import CONF_TYPE
+from homeassistant.data_entry_flow import AbortFlow
 from homeassistant.helpers import selector
 from homeassistant.helpers.schema_config_entry_flow import (
+    SchemaCommonFlowHandler,
     SchemaConfigFlowHandler,
     SchemaFlowFormStep,
 )
@@ -51,14 +53,16 @@
     }
 )
 
-CONFIG_SCHEMA = vol.Schema(
-    {
-        vol.Required("name"): selector.TextSelector(),
-    }
-).extend(OPTIONS_SCHEMA.schema)
+CONFIG_SCHEMA = vol.Schema({})
+
+
+async def migrate_to_groups(handler: SchemaCommonFlowHandler) -> vol.Schema:
+    """Abort flow as migrate to groups."""
+    raise AbortFlow("migrated_to_groups")
+
 
 CONFIG_FLOW = {
-    "user": SchemaFlowFormStep(CONFIG_SCHEMA),
+    "user": SchemaFlowFormStep(migrate_to_groups),
 }
 
 OPTIONS_FLOW = {

homeassistant/components/min_max/repairs.py

@@ -0,0 +1,117 @@
+"""Repairs platform for the Min/Max integration."""
+
+from types import MappingProxyType
+from typing import TYPE_CHECKING, Any, cast
+
+import voluptuous as vol
+
+from homeassistant import data_entry_flow
+from homeassistant.components.group import (
+    CONF_ENTITIES,
+    CONF_GROUP_TYPE,
+    CONF_HIDE_MEMBERS,
+    CONF_IGNORE_NON_NUMERIC,
+    DOMAIN as GROUP_DOMAIN,
+)
+from homeassistant.components.repairs import ConfirmRepairFlow, RepairsFlow
+from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN
+from homeassistant.config_entries import SOURCE_USER, ConfigEntry, ConfigEntryDisabler
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers import entity_registry as er
+
+from .const import CONF_ENTITY_IDS, CONF_ROUND_DIGITS, DOMAIN
+
+
+class MigrateToGroupSensorFlow(RepairsFlow):
+    """Handler for an issue fixing flow."""
+
+    def __init__(self, entry: ConfigEntry) -> None:
+        """Create flow."""
+        self.entry = entry
+        super().__init__()
+
+    async def async_step_init(
+        self, user_input: dict[str, str] | None = None
+    ) -> data_entry_flow.FlowResult:
+        """Handle the first step of a fix flow."""
+        return await self.async_step_migrate()
+
+    async def async_step_migrate(
+        self, user_input: dict[str, Any] | None = None
+    ) -> data_entry_flow.FlowResult:
+        """Handle the migration step of a fix flow."""
+        entity_reg = er.async_get(self.hass)
+        old_entity = entity_reg.async_get_entity_id(
+            SENSOR_DOMAIN, DOMAIN, self.entry.entry_id
+        )
+        if not old_entity:
+            return self.async_abort(reason="entity_not_found")
+
+        if user_input is not None:
+            config = dict(self.entry.options)
+            config[CONF_ENTITIES] = config.pop(CONF_ENTITY_IDS)
+            config.pop(CONF_ROUND_DIGITS)
+            # Set group sensor defaults
+            config[CONF_HIDE_MEMBERS] = False
+            config[CONF_IGNORE_NON_NUMERIC] = False
+            config[CONF_GROUP_TYPE] = SENSOR_DOMAIN
+
+            new_config_entry = ConfigEntry(
+                data={},
+                discovery_keys=MappingProxyType({}),
+                domain=GROUP_DOMAIN,
+                minor_version=1,
+                options=config,
+                source=SOURCE_USER,
+                subentries_data=[],
+                title=self.entry.title,
+                unique_id=None,
+                version=1,
+                disabled_by=ConfigEntryDisabler.USER,
+            )
+
+            if not await self.hass.config_entries.async_unload(self.entry.entry_id):
+                return self.async_abort(reason="unload_failed")
+            await self.hass.config_entries.async_add(new_config_entry)
+            try:
+                entity_reg.async_update_entity_platform(
+                    old_entity,
+                    GROUP_DOMAIN,
+                    new_config_entry_id=new_config_entry.entry_id,
+                    new_unique_id=new_config_entry.entry_id,
+                )
+            except ValueError:
+                return self.async_abort(reason="entity_update_failed")
+            await self.hass.config_entries.async_set_disabled_by(
+                entry_id=new_config_entry.entry_id, disabled_by=None
+            )
+            await self.hass.config_entries.async_remove(self.entry.entry_id)
+
+            return self.async_create_entry(data={})
+
+        entity_info = entity_reg.async_get(old_entity)
+        if TYPE_CHECKING:
+            assert entity_info
+        title = er.async_get_full_entity_name(self.hass, entity_info)
+
+        return self.async_show_form(
+            step_id="migrate",
+            data_schema=vol.Schema({}),
+            description_placeholders={"title": title},
+        )
+
+
+async def async_create_fix_flow(
+    hass: HomeAssistant,
+    issue_id: str,
+    data: dict[str, Any] | None,
+) -> RepairsFlow:
+    """Create flow."""
+    if data and (entry_id := data.get("entry_id")):
+        entry_id = cast(str, entry_id)
+        entry = hass.config_entries.async_get_entry(entry_id)
+        if TYPE_CHECKING:
+            assert entry
+        return MigrateToGroupSensorFlow(entry)
+
+    return ConfirmRepairFlow()

homeassistant/components/min_max/sensor.py

@@ -3,12 +3,15 @@
 from __future__ import annotations
 
 from datetime import datetime
+import hashlib
+import json
 import logging
 import statistics
 from typing import Any
 
 import voluptuous as vol
 
+from homeassistant.components.group import CONF_ENTITIES
 from homeassistant.components.sensor import (
     PLATFORM_SCHEMA as SENSOR_PLATFORM_SCHEMA,
     SensorDeviceClass,
@@ -20,6 +23,7 @@
     ATTR_ENTITY_ID,
     ATTR_UNIT_OF_MEASUREMENT,
     CONF_NAME,
+    CONF_PLATFORM,
     CONF_TYPE,
     CONF_UNIQUE_ID,
     STATE_UNAVAILABLE,
@@ -34,8 +38,10 @@
     AddEntitiesCallback,
 )
 from homeassistant.helpers.event import async_track_state_change_event
+from homeassistant.helpers.issue_registry import IssueSeverity, async_create_issue
 from homeassistant.helpers.reload import async_setup_reload_service
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType, StateType
+from homeassistant.util import yaml as yaml_util
 
 from . import PLATFORMS
 from .const import CONF_ENTITY_IDS, CONF_ROUND_DIGITS, DOMAIN
@@ -53,6 +59,7 @@
 ATTR_RANGE = "range"
 ATTR_SUM = "sum"
 
+
 ICON = "mdi:calculator"
 
 SENSOR_TYPES = {
@@ -105,6 +112,36 @@ async def async_setup_entry(
     )
 
 
+async def yaml_deprecation_notice(hass: HomeAssistant, config: ConfigType) -> None:
+    """Raise repair issue for YAML configuration deprecation."""
+    platform_config = config.copy()
+    platform_config[CONF_ENTITIES] = platform_config.pop(CONF_ENTITY_IDS)
+    platform_config.pop(CONF_ROUND_DIGITS)
+    platform_config.pop(CONF_PLATFORM)
+    if CONF_NAME not in platform_config:
+        platform_config[CONF_NAME] = f"{platform_config[CONF_TYPE]} sensor".capitalize()
+    yaml_config = yaml_util.dump(platform_config)
+    yaml_config = yaml_config.replace("\n", "\n    ")
+    yaml_config = "```yaml\nsensor:\n  - platform: group\n    " + yaml_config + "\n```"
+
+    def make_hash(config: dict[str, Any]) -> str:
+        d = hashlib.sha1(json.dumps(config, sort_keys=True).encode())
+        return d.hexdigest()
+
+    issue_id = f"yaml_deprecated-{make_hash(platform_config)}"
+    async_create_issue(
+        hass,
+        DOMAIN,
+        issue_id,
+        breaks_in_ha_version="2026.12.0",
+        is_fixable=False,
+        severity=IssueSeverity.WARNING,
+        learn_more_url="https://www.home-assistant.io/integrations/group/",
+        translation_key="yaml_deprecated",
+        translation_placeholders={"yaml_config": yaml_config},
+    )
+
+
 async def async_setup_platform(
     hass: HomeAssistant,
     config: ConfigType,
@@ -119,6 +156,7 @@ async def async_setup_platform(
     unique_id = config.get(CONF_UNIQUE_ID)
 
     await async_setup_reload_service(hass, DOMAIN, PLATFORMS)
+    await yaml_deprecation_notice(hass, config)
 
     async_add_entities(
         [MinMaxSensor(entity_ids, name, sensor_type, round_digits, unique_id)]

homeassistant/components/min_max/strings.json

@@ -1,31 +1,47 @@
 {
   "config": {
+    "abort": {
+      "migrated_to_groups": "The Min/Max helper has been migrated to use Group sensors. Please use the Group helper instead."
+    },
     "step": {
       "user": {
-        "data": {
-          "entity_ids": "Input entities",
-          "name": "[%key:common::config_flow::data::name%]",
-          "round_digits": "Precision",
-          "type": "Statistic characteristic"
-        },
-        "data_description": {
-          "round_digits": "Controls the number of decimal digits in the output when the statistics characteristic is mean, median or sum."
-        },
-        "description": "Create a sensor that calculates a min, max, mean, median or sum from a list of input sensors.",
+        "description": "Min/Max helper has been deprecated, please use the Group helper instead.",
         "title": "[%key:component::min_max::title%]"
       }
     }
   },
+  "issues": {
+    "migrate_to_group_sensor": {
+      "fix_flow": {
+        "abort": {
+          "entity_not_found": "Entity could not be found, please restart repairing the issue.",
+          "entity_update_failed": "Failed to update the entity to a Group sensor, please manually remove the obsolete entity.",
+          "unload_failed": "Failed to unload the Min/Max helper, please restart repairing the issue."
+        },
+        "step": {
+          "migrate": {
+            "description": "The Min/Max helper has been deprecated and {title} will be migrated to a Group sensor when you click submit to fix this repair.",
+            "title": "[%key:component::min_max::issues::migrate_to_group_sensor::title%]"
+          }
+        }
+      },
+      "title": "Min/Max helper has been deprecated"
+    },
+    "yaml_deprecated": {
+      "description": "The Min/Max helper has been deprecated and you should use Group sensors instead.\n\nReplace your Min/Max YAML configuration with this converted configuration:\n{yaml_config}\n\nOnce you have replaced your YAML configuration, restart Home Assistant to use the Group helper instead.\n\nThe Group helper has more configuration possibilities. Refer to the documentation by clicking Learn More.",
+      "title": "[%key:component::min_max::issues::migrate_to_group_sensor::title%]"
+    }
+  },
   "options": {
     "step": {
       "init": {
         "data": {
-          "entity_ids": "[%key:component::min_max::config::step::user::data::entity_ids%]",
-          "round_digits": "[%key:component::min_max::config::step::user::data::round_digits%]",
-          "type": "[%key:component::min_max::config::step::user::data::type%]"
+          "entity_ids": "Input entities",
+          "round_digits": "Precision",
+          "type": "Statistic characteristic"
         },
         "data_description": {
-          "round_digits": "[%key:component::min_max::config::step::user::data_description::round_digits%]"
+          "round_digits": "Controls the number of decimal digits in the output when the statistics characteristic is mean, median or sum."
         }
       }
     }

homeassistant/helpers/entity_registry.py

@@ -1932,7 +1932,7 @@ def async_update_entity_platform(
         """
         if (
             state := self.hass.states.get(entity_id)
-        ) is not None and state.state != STATE_UNKNOWN:
+        ) is not None and state.state not in (STATE_UNKNOWN, STATE_UNAVAILABLE):
             raise ValueError("Only entities that haven't been loaded can be migrated")
 
         old = self.entities[entity_id]