Address niobos review feedback

- Add super().__init__() to ConfigFlow and OptionsFlowHandler
- Extract duplicate experimental schema into _get_experimental_schema() helper
- Make set_remote_temp_mode() async and move set_current_temperature(None)
  call into it when disabling remote mode
- Remove unused type: ignore comments in climate.py
- Update tests for async set_remote_temp_mode

Author: ashleigh-hopkins

custom_components/mitsubishi/climate.py

@@ -118,12 +118,12 @@ class MitsubishiClimate(MitsubishiEntity, ClimateEntity):
 
     _attr_supported_features = (
         0
-        | ClimateEntityFeature.TURN_ON  # type: ignore[attr-defined]
-        | ClimateEntityFeature.TURN_OFF  # type: ignore[attr-defined]
+        | ClimateEntityFeature.TURN_ON
+        | ClimateEntityFeature.TURN_OFF
         | ClimateEntityFeature.TARGET_TEMPERATURE
         | ClimateEntityFeature.FAN_MODE
         | ClimateEntityFeature.SWING_MODE
-        | ClimateEntityFeature.SWING_HORIZONTAL_MODE  # type: ignore[attr-defined]
+        | ClimateEntityFeature.SWING_HORIZONTAL_MODE
     )
 
     def __init__(

custom_components/mitsubishi/config_flow.py

@@ -29,6 +29,30 @@
     DOMAIN,
 )
 
+
+def _get_experimental_schema(suggested_value: str | None = None) -> vol.Schema:
+    """Get the schema for experimental features configuration."""
+    entity_selector = selector.EntitySelector(
+        selector.EntitySelectorConfig(
+            domain=["sensor", "input_number", "number"],
+        )
+    )
+    if suggested_value:
+        return vol.Schema(
+            {
+                vol.Optional(
+                    CONF_EXTERNAL_TEMP_ENTITY,
+                    description={"suggested_value": suggested_value},
+                ): entity_selector,
+            }
+        )
+    return vol.Schema(
+        {
+            vol.Optional(CONF_EXTERNAL_TEMP_ENTITY): entity_selector,
+        }
+    )
+
+
 _LOGGER = logging.getLogger(__name__)
 
 STEP_USER_DATA_SCHEMA = vol.Schema(
@@ -87,6 +111,7 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
 
     def __init__(self) -> None:
         """Initialize the config flow."""
+        super().__init__()
         self._connection_data: dict[str, Any] = {}
         self._experimental_features: bool = False
         self._device_info: dict[str, Any] = {}
@@ -151,17 +176,7 @@ async def async_step_experimental(self, user_input: dict[str, Any] | None = None
             external_temp_entity = user_input.get(CONF_EXTERNAL_TEMP_ENTITY)
             return self._create_entry(external_temp_entity=external_temp_entity)
 
-        experimental_schema = vol.Schema(
-            {
-                vol.Optional(CONF_EXTERNAL_TEMP_ENTITY): selector.EntitySelector(
-                    selector.EntitySelectorConfig(
-                        domain=["sensor", "input_number", "number"],
-                    )
-                ),
-            }
-        )
-
-        return self.async_show_form(step_id="experimental", data_schema=experimental_schema)
+        return self.async_show_form(step_id="experimental", data_schema=_get_experimental_schema())
 
     def _create_entry(self, external_temp_entity: str | None) -> Any:
         """Create the config entry with options."""
@@ -186,6 +201,7 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
 
     def __init__(self, config_entry: config_entries.ConfigEntry) -> None:
         """Initialize options flow."""
+        super().__init__()
         self._config_entry = config_entry
         self._connection_data: dict[str, Any] = {}
         self._experimental_features: bool = False
@@ -266,21 +282,11 @@ async def async_step_experimental(self, user_input: dict[str, Any] | None = None
 
         current_external_temp_entity = self.config_entry.options.get(CONF_EXTERNAL_TEMP_ENTITY, "")
 
-        experimental_schema = vol.Schema(
-            {
-                vol.Optional(
-                    CONF_EXTERNAL_TEMP_ENTITY,
-                    description={"suggested_value": current_external_temp_entity},
-                ): selector.EntitySelector(
-                    selector.EntitySelectorConfig(
-                        domain=["sensor", "input_number", "number"],
-                    )
-                ),
-            }
+        return self.async_show_form(
+            step_id="experimental",
+            data_schema=_get_experimental_schema(current_external_temp_entity or None),
         )
 
-        return self.async_show_form(step_id="experimental", data_schema=experimental_schema)
-
     async def _async_save_options(self, external_temp_entity: str | None) -> Any:
         """Save connection data and options."""
         # Update the config entry data (connection settings)

custom_components/mitsubishi/coordinator.py

@@ -46,11 +46,18 @@ def __init__(
         self._remote_temp_mode = config_entry.options.get(CONF_REMOTE_TEMP_MODE, False)
         self._startup_mode_applied = False
 
-    def set_remote_temp_mode(self, enabled: bool) -> None:
-        """Set whether remote temperature mode is enabled and persist to storage."""
+    async def set_remote_temp_mode(self, enabled: bool) -> None:
+        """Set whether remote temperature mode is enabled and persist to storage.
+
+        When disabling remote mode, this also tells the AC to use its internal sensor.
+        """
         self._remote_temp_mode = enabled
         _LOGGER.info("Remote temperature mode set to: %s", enabled)
 
+        # When disabling remote mode, tell the AC to use internal sensor
+        if not enabled:
+            await self.hass.async_add_executor_job(self.controller.set_current_temperature, None)
+
         # Persist to config entry options
         if self.config_entry is not None:
             new_options = dict(self.config_entry.options)
@@ -114,8 +121,7 @@ async def _send_remote_temperature(self) -> None:
                 "Remote temperature mode enabled but no external entity configured, "
                 "falling back to internal sensor"
             )
-            await self.hass.async_add_executor_job(self.controller.set_current_temperature, None)
-            self.set_remote_temp_mode(False)
+            await self.set_remote_temp_mode(False)
             return
 
         state = self.hass.states.get(external_entity_id)
@@ -125,8 +131,7 @@ async def _send_remote_temperature(self) -> None:
                 "External temperature entity %s not found, falling back to internal sensor",
                 external_entity_id,
             )
-            await self.hass.async_add_executor_job(self.controller.set_current_temperature, None)
-            self.set_remote_temp_mode(False)
+            await self.set_remote_temp_mode(False)
             return
 
         if state.state in (STATE_UNAVAILABLE, STATE_UNKNOWN):
@@ -135,8 +140,7 @@ async def _send_remote_temperature(self) -> None:
                 external_entity_id,
                 state.state,
             )
-            await self.hass.async_add_executor_job(self.controller.set_current_temperature, None)
-            self.set_remote_temp_mode(False)
+            await self.set_remote_temp_mode(False)
             return
 
         try:
@@ -156,5 +160,4 @@ async def _send_remote_temperature(self) -> None:
                 external_entity_id,
                 e,
             )
-            await self.hass.async_add_executor_job(self.controller.set_current_temperature, None)
-            self.set_remote_temp_mode(False)
+            await self.set_remote_temp_mode(False)

custom_components/mitsubishi/select.py

@@ -103,12 +103,8 @@ def current_option(self) -> str | None:
     async def async_select_option(self, option: str) -> None:
         """Set the temperature source mode."""
         if option == TEMP_SOURCE_INTERNAL:
-            # Switch to internal sensor
-            self.coordinator.set_remote_temp_mode(False)
-            await self.hass.async_add_executor_job(
-                self.coordinator.controller.set_current_temperature,
-                None,
-            )
+            # Switch to internal sensor (set_remote_temp_mode handles the AC command)
+            await self.coordinator.set_remote_temp_mode(False)
             _LOGGER.info("Switched to internal temperature sensor")
         else:
             # Switch to remote sensor - check if external entity is configured
@@ -139,7 +135,7 @@ async def async_select_option(self, option: str) -> None:
                 return
 
             # Enable remote mode and send the temperature
-            self.coordinator.set_remote_temp_mode(True)
+            await self.coordinator.set_remote_temp_mode(True)
             await self.hass.async_add_executor_job(
                 self.coordinator.controller.set_current_temperature,
                 temp,

tests/test_coordinator.py

@@ -126,11 +126,14 @@ async def test_coordinator_set_remote_temp_mode(
         hass, mock_mitsubishi_controller, mock_config_entry
     )
 
-    coordinator.set_remote_temp_mode(True)
+    # Enable remote mode (no hardware call when enabling)
+    await coordinator.set_remote_temp_mode(True)
     assert coordinator.remote_temp_mode is True
 
-    coordinator.set_remote_temp_mode(False)
+    # Disable remote mode (should call set_current_temperature(None))
+    await coordinator.set_remote_temp_mode(False)
     assert coordinator.remote_temp_mode is False
+    mock_mitsubishi_controller.set_current_temperature.assert_called_with(None)
 
 
 @pytest.fixture

tests/test_select.py

@@ -184,35 +184,32 @@ async def test_temperature_source_select_switch_to_internal(
     hass, mock_coordinator, mock_config_entry_experimental
 ):
     """Test switching temperature source to internal."""
-    mock_coordinator.set_remote_temp_mode = MagicMock()
+    mock_coordinator.set_remote_temp_mode = AsyncMock()
     select = MitsubishiTemperatureSourceSelect(mock_coordinator, mock_config_entry_experimental)
     select.hass = hass
     select.async_write_ha_state = MagicMock()
 
-    with patch.object(hass, "async_add_executor_job", new=AsyncMock()) as mock_executor:
-        await select.async_select_option("Internal")
+    await select.async_select_option("Internal")
 
-        mock_coordinator.set_remote_temp_mode.assert_called_once_with(False)
-        mock_executor.assert_called_once()
-        select.async_write_ha_state.assert_called_once()
+    # set_remote_temp_mode(False) handles the AC command internally
+    mock_coordinator.set_remote_temp_mode.assert_called_once_with(False)
+    select.async_write_ha_state.assert_called_once()
 
 
 @pytest.mark.asyncio
 async def test_temperature_source_select_switch_to_remote_no_entity(
     hass, mock_coordinator, mock_config_entry
 ):
     """Test switching to remote fails when no external entity configured."""
-    mock_coordinator.set_remote_temp_mode = MagicMock()
+    mock_coordinator.set_remote_temp_mode = AsyncMock()
     select = MitsubishiTemperatureSourceSelect(mock_coordinator, mock_config_entry)
     select.hass = hass
     select.async_write_ha_state = MagicMock()
 
-    with patch.object(hass, "async_add_executor_job", new=AsyncMock()) as mock_executor:
-        await select.async_select_option("Remote")
+    await select.async_select_option("Remote")
 
-        # Should not change mode when no entity configured
-        mock_coordinator.set_remote_temp_mode.assert_not_called()
-        mock_executor.assert_not_called()
+    # Should not change mode when no entity configured
+    mock_coordinator.set_remote_temp_mode.assert_not_called()
 
 
 @pytest.mark.asyncio