Make options and last_reset_template conditional, use sections for advanced settings

Author: jbouwh

homeassistant/components/mqtt/config_flow.py

@@ -241,8 +241,6 @@
         translation_key=CONF_PLATFORM,
     )
 )
-RESET_IF_EMPTY = {CONF_OPTIONS}
-
 TEMPLATE_SELECTOR = TemplateSelector(TemplateSelectorConfig())
 
 SUBENTRY_AVAILABILITY_SCHEMA = vol.Schema(
@@ -346,7 +344,12 @@ def unit_of_measurement_selector(user_data: dict[str, Any | None]) -> Selector:
             cv.positive_int,
             section="advanced_settings",
         ),
-        CONF_OPTIONS: PlatformField(OPTIONS_SELECTOR, False, cv.ensure_list),
+        CONF_OPTIONS: PlatformField(
+            OPTIONS_SELECTOR,
+            False,
+            cv.ensure_list,
+            conditions=({"device_class": "enum"},),
+        ),
     },
 }
 PLATFORM_MQTT_FIELDS = {
@@ -379,7 +382,8 @@ def unit_of_measurement_selector(user_data: dict[str, Any | None]) -> Selector:
     },
 }
 ENTITY_CONFIG_VALIDATOR: dict[
-    str, Callable[[dict[str, Any], dict[str, str]], dict[str, Any]] | None
+    str,
+    Callable[[dict[str, Any], dict[str, str], list[str] | None], dict[str, Any]] | None,
 ] = {
     Platform.NOTIFY.value: None,
     Platform.SENSOR.value: validate_sensor_state_and_device_class_config,
@@ -445,22 +449,36 @@ def validate_field(
         errors[field] = error
 
 
+@callback
+def _check_conditions(
+    platform_field: PlatformField, component: dict[str, Any] | None = None
+) -> bool:
+    """Only include field if one of conditions match, or no conditions are set."""
+    if platform_field.conditions is None or component is None:
+        return True
+    return any(
+        all(component.get(key) == value for key, value in condition.items())
+        for condition in platform_field.conditions
+    )
+
+
 @callback
 def validate_user_input(
     user_input: dict[str, Any],
     data_schema_fields: dict[str, PlatformField],
     errors: dict[str, str],
-    config_validator: Callable[[dict[str, Any], dict[str, str]], dict[str, str]]
+    component_data: dict[str, Any] | None,
+    config_validator: Callable[
+        [dict[str, Any], dict[str, str], list[str] | None], dict[str, str]
+    ]
     | None = None,
-    component_data: dict[str, Any] | None = None,
 ) -> dict[str, Any]:
     """Validate user input."""
     # Merge sections
+    reset_fields: list[str] = []
     merged_user_input: dict[str, Any] = {}
     for key, value in user_input.items():
         # Omit empty lists that are not allowed to be empty
-        if key in RESET_IF_EMPTY and not value:
-            continue
         if isinstance(value, dict):
             merged_user_input.update(value)
         else:
@@ -474,10 +492,30 @@ def validate_user_input(
             errors[field] = data_schema_fields[field].error or "invalid_input"
 
     if config_validator is not None:
-        config = merged_user_input
-        if component_data is not None:
-            config |= component_data
-        config_validator(config, errors)
+        if TYPE_CHECKING:
+            assert component_data is not None
+        schema_fields = tuple(
+            {
+                key
+                for key, platform_field in data_schema_fields.items()
+                if _check_conditions(platform_field, component_data)
+            }
+            - set(merged_user_input)
+        )
+        config_validator(
+            {
+                key: value
+                for key, value in component_data.items()
+                if key not in schema_fields
+            }
+            | merged_user_input,
+            errors,
+            reset_fields,
+        )
+
+    for field in reset_fields:
+        if component_data and field in component_data:
+            del component_data[field]
 
     return merged_user_input
 
@@ -490,25 +528,14 @@ def data_schema_from_fields(
     user_input: dict[str, Any] | None = None,
 ) -> vol.Schema:
     """Generate custom data schema from platform fields."""
-
-    def _check_conditions(
-        platform_field: PlatformField,
-    ) -> bool:
-        """Only include field if one of conditions match, or no conditions are set."""
-        if platform_field.conditions is None or component is None:
-            return True
-        return any(
-            all(component.get(key) == value for key, value in condition.items())
-            for condition in platform_field.conditions
-        )
-
-    user_data = component
+    user_data = deepcopy(component)
     if user_data is not None and user_input is not None:
         user_data |= user_input
     sections: dict[str | None, None] = {
         field_details.section: None for field_details in data_schema_fields.values()
     }
     data_schema: dict[Any, Any] = {}
+    all_data_element_options: set[Any] = set()
     for schema_section in sections:
         data_schema_element = {
             vol.Required(field_name, default=field_details.default)
@@ -521,23 +548,25 @@ def _check_conditions(
             for field_name, field_details in data_schema_fields.items()
             if field_details.section == schema_section
             and (not field_details.exclude_from_reconfig or not reconfig)
-            and _check_conditions(field_details)
+            and _check_conditions(field_details, user_data)
         }
+        data_element_options = set(data_schema_element)
+        all_data_element_options |= data_element_options
+        if schema_section is None:
+            data_schema.update(data_schema_element)
+            continue
         collapsed = (
-            bool(set(data_schema_element) - set(user_data))  # type: ignore[arg-type]
+            bool(data_element_options - set(user_data))  # type: ignore[arg-type]
             if user_data is not None
             else True
         )
-        if schema_section is None:
-            data_schema.update(data_schema_element)
-            continue
         data_schema[vol.Optional(schema_section)] = section(
             vol.Schema(data_schema_element), SectionConfig({"collapsed": collapsed})
         )
 
     # Reset all fields from the component not in the schema
     if component:
-        filtered_fields = set(data_schema_fields) - set(data_schema)
+        filtered_fields = set(data_schema_fields) - all_data_element_options
         for field in filtered_fields:
             if field in component:
                 del component[field]
@@ -1066,7 +1095,7 @@ class MQTTSubentryFlowHandler(ConfigSubentryFlow):
 
     @callback
     def update_component_fields(
-        self, data_schema: vol.Schema, user_input: dict[str, Any]
+        self, data_schema: vol.Schema, merged_user_input: dict[str, Any]
     ) -> None:
         """Update the componment fields."""
         if TYPE_CHECKING:
@@ -1076,10 +1105,10 @@ def update_component_fields(
         for field in [
             form_field
             for form_field in data_schema.schema
-            if form_field in component_data and form_field not in user_input
+            if form_field in component_data and form_field not in merged_user_input
         ]:
             component_data.pop(field)
-        component_data.update(user_input)
+        component_data.update(merged_user_input)
 
     @callback
     def generate_names(self) -> tuple[str, str]:
@@ -1097,7 +1126,7 @@ def generate_names(self) -> tuple[str, str]:
 
     @callback
     def add_suggested_values_from_component_data_to_schema(
-        self, data_schema: vol.Schema, data_schema_fields: dict[str, PlatformField]
+        self, data_schema: vol.Schema
     ) -> vol.Schema:
         """Add suggestions from component data to data schema."""
         if TYPE_CHECKING:
@@ -1123,14 +1152,15 @@ def _apply_suggested_value(
             if not isinstance(value, section):
                 continue
             data_section_schema = value.schema.schema
-            value.schema = vol.Schema(
+            new_schema = vol.Schema(
                 {
                     _apply_suggested_value(
                         section_field, component.get(section_field)
                     ): section_field_selector
                     for section_field, section_field_selector in data_section_schema.items()
                 }
             )
+            value.schema = new_schema
 
         return vol.Schema(schema)
 
@@ -1182,16 +1212,16 @@ async def async_step_entity(
         data_schema_fields = COMMON_ENTITY_FIELDS
         entity_name_label: str = ""
         platform_label: str = ""
+        component: dict[str, Any] | None = None
         if reconfig := (self._component_id is not None):
-            name: str | None = self._subentry_data["components"][
-                self._component_id
-            ].get(CONF_NAME)
+            component = self._subentry_data["components"][self._component_id]
+            name: str | None = component.get(CONF_NAME)
             platform_label = f"{self._subentry_data['components'][self._component_id][CONF_PLATFORM]} "
             entity_name_label = f" ({name})" if name is not None else ""
         data_schema = data_schema_from_fields(data_schema_fields, reconfig=reconfig)
         if user_input is not None:
             merged_user_input = validate_user_input(
-                user_input, data_schema_fields, errors
+                user_input, data_schema_fields, errors, component
             )
             if not errors:
                 if self._component_id is None:
@@ -1202,7 +1232,7 @@ async def async_step_entity(
             data_schema = self.add_suggested_values_to_schema(data_schema, user_input)
         elif self.source == SOURCE_RECONFIGURE and self._component_id is not None:
             data_schema = self.add_suggested_values_from_component_data_to_schema(
-                data_schema, data_schema_fields
+                data_schema
             )
         device_name = self._subentry_data[CONF_DEVICE][CONF_NAME]
         return self.async_show_form(
@@ -1291,6 +1321,7 @@ async def async_step_entity_platform_config(
                 user_input,
                 data_schema_fields,
                 errors,
+                component,
                 ENTITY_CONFIG_VALIDATOR[platform],
             )
             if not errors:
@@ -1300,7 +1331,7 @@ async def async_step_entity_platform_config(
             data_schema = self.add_suggested_values_to_schema(data_schema, user_input)
         else:
             data_schema = self.add_suggested_values_from_component_data_to_schema(
-                data_schema, data_schema_fields
+                data_schema
             )
 
         device_name, full_entity_name = self.generate_names()
@@ -1340,8 +1371,8 @@ async def async_step_mqtt_platform_config(
                 user_input,
                 data_schema_fields,
                 errors,
+                component,
                 ENTITY_CONFIG_VALIDATOR[platform],
-                self._subentry_data["components"][self._component_id],
             )
             if not errors:
                 self.update_component_fields(data_schema, merged_user_input)
@@ -1353,7 +1384,7 @@ async def async_step_mqtt_platform_config(
             data_schema = self.add_suggested_values_to_schema(data_schema, user_input)
         else:
             data_schema = self.add_suggested_values_from_component_data_to_schema(
-                data_schema, data_schema_fields
+                data_schema
             )
         device_name, full_entity_name = self.generate_names()
         return self.async_show_form(

homeassistant/components/mqtt/strings.json

@@ -250,7 +250,7 @@
           },
           "sections": {
             "advanced_settings": {
-              "name": "Advanced options",
+              "name": "Advanced settings",
               "data": {
                 "expire_after": "Expire after"
               },
@@ -274,7 +274,8 @@
         "invalid_uom": "The unit of measurement is not allowed with the selected device class, please use the correct device class, or pick a valid unit of measurement from the list",
         "invalid_url": "Invalid URL",
         "options_not_allowed_with_state_class_or_uom": "The 'Options' setting is not allowed when state class or unit of measurement are used",
-        "options_device_class_enum": "The 'Options' setting must be used with the Enumeration device class'"
+        "options_device_class_enum": "The 'Options' setting must be used with the Enumeration device class'. If you continue, the existing options will be reset",
+        "options_with_enum_device_class": "Configure options for the enumeration sensor"
       }
     }
   },

homeassistant/components/mqtt/util.py

@@ -9,7 +9,7 @@
 import os
 from pathlib import Path
 import tempfile
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 import voluptuous as vol
 
@@ -435,23 +435,30 @@ def learn_more_url(platform: str) -> str:
 
 @callback
 def validate_sensor_state_and_device_class_config(
-    config: ConfigType, errors: dict[str, str] | None = None
+    config: ConfigType,
+    errors: dict[str, str] | None = None,
+    reset_fields: list[str] | None = None,
 ) -> ConfigType:
     """Validate the sensor options, state and device class config."""
     if (
         CONF_LAST_RESET_VALUE_TEMPLATE in config
         and (state_class := config.get(CONF_STATE_CLASS)) != SensorStateClass.TOTAL
     ):
-        raise vol.Invalid(
-            f"The option `{CONF_LAST_RESET_VALUE_TEMPLATE}` cannot be used "
-            f"together with state class `{state_class}`"
-        )
+        if errors is None:
+            raise vol.Invalid(
+                f"The option `{CONF_LAST_RESET_VALUE_TEMPLATE}` cannot be used "
+                f"together with state class `{state_class}`"
+            )
+        if reset_fields is not None:
+            reset_fields.append(CONF_LAST_RESET_VALUE_TEMPLATE)
 
     # Only allow `options` to be set for `enum` sensors
     # to limit the possible sensor values
     if (options := config.get(CONF_OPTIONS)) is not None:
         if not options:
-            raise vol.Invalid("An empty options list is not allowed")
+            if reset_fields is None:
+                raise vol.Invalid("An empty options list is not allowed")
+            reset_fields.append(CONF_OPTIONS)
         if config.get(CONF_STATE_CLASS) or config.get(CONF_UNIT_OF_MEASUREMENT):
             if errors is None:
                 raise vol.Invalid(
@@ -467,11 +474,22 @@ def validate_sensor_state_and_device_class_config(
                     f"together with device class `{SensorDeviceClass.ENUM}`, "
                     f"got `{CONF_DEVICE_CLASS}` '{device_class}'"
                 )
-            errors[CONF_OPTIONS] = "options_device_class_enum"
+            if TYPE_CHECKING:
+                assert reset_fields is not None
+            errors[CONF_DEVICE_CLASS] = "options_device_class_enum"
+            reset_fields.append(CONF_OPTIONS)
 
-    if (device_class := config.get(CONF_DEVICE_CLASS)) is None or (
-        unit_of_measurement := config.get(CONF_UNIT_OF_MEASUREMENT)
-    ) is None:
+    if (
+        (device_class := config.get(CONF_DEVICE_CLASS)) == SensorDeviceClass.ENUM
+        and errors is not None
+        and CONF_OPTIONS not in config
+    ):
+        errors[CONF_OPTIONS] = "options_with_enum_device_class"
+
+    if (
+        device_class is None
+        or (unit_of_measurement := config.get(CONF_UNIT_OF_MEASUREMENT)) is None
+    ):
         return config
 
     if (