Add WattTime config option for showing the monitored location on the map (#57129)

* Add WattTime configuration option for showing the monitored location on the map

* Update tests

* Explicitly pass entry

* Tests

homeassistant/components/watttime/__init__.py

@@ -69,6 +69,8 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 
     hass.config_entries.async_setup_platforms(entry, PLATFORMS)
 
+    entry.async_on_unload(entry.add_update_listener(async_reload_entry))
+
     return True
 
 
@@ -79,3 +81,8 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         hass.data[DOMAIN].pop(entry.entry_id)
 
     return unload_ok
+
+
+async def async_reload_entry(hass: HomeAssistant, config_entry: ConfigEntry) -> None:
+    """Handle an options update."""
+    await hass.config_entries.async_reload(config_entry.entry_id)

homeassistant/components/watttime/config_flow.py

@@ -8,6 +8,7 @@ from aiowatttime.errors import CoordinatesNotFoundError, InvalidCredentialsError
 import voluptuous as vol
 
 from homeassistant import config_entries
+from homeassistant.config_entries import ConfigEntry, OptionsFlow
 from homeassistant.const import (
     CONF_LATITUDE,
     CONF_LONGITUDE,
@@ -22,6 +23,7 @@ from homeassistant.helpers.typing import ConfigType
 from .const import (
     CONF_BALANCING_AUTHORITY,
     CONF_BALANCING_AUTHORITY_ABBREV,
+    CONF_SHOW_ON_MAP,
     DOMAIN,
     LOGGER,
 )
@@ -118,6 +120,12 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
         self._data[CONF_PASSWORD] = password
         return await self.async_step_location()
 
+    @staticmethod
+    @callback
+    def async_get_options_flow(config_entry: ConfigEntry) -> OptionsFlow:
+        """Define the config flow to handle options."""
+        return WattTimeOptionsFlowHandler(config_entry)
+
     async def async_step_coordinates(
         self, user_input: dict[str, Any] | None = None
     ) -> FlowResult:
@@ -222,3 +230,30 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
             "user",
             STEP_USER_DATA_SCHEMA,
         )
+
+
+class WattTimeOptionsFlowHandler(config_entries.OptionsFlow):
+    """Handle a WattTime options flow."""
+
+    def __init__(self, entry: ConfigEntry) -> None:
+        """Initialize."""
+        self.entry = entry
+
+    async def async_step_init(
+        self, user_input: dict[str, Any] | None = None
+    ) -> FlowResult:
+        """Manage the options."""
+        if user_input is not None:
+            return self.async_create_entry(title="", data=user_input)
+
+        return self.async_show_form(
+            step_id="init",
+            data_schema=vol.Schema(
+                {
+                    vol.Required(
+                        CONF_SHOW_ON_MAP,
+                        default=self.entry.options.get(CONF_SHOW_ON_MAP, True),
+                    ): bool
+                }
+            ),
+        )

homeassistant/components/watttime/const.py

@@ -7,5 +7,6 @@ LOGGER = logging.getLogger(__package__)
 
 CONF_BALANCING_AUTHORITY = "balancing_authority"
 CONF_BALANCING_AUTHORITY_ABBREV = "balancing_authority_abbreviation"
+CONF_SHOW_ON_MAP = "show_on_map"
 
 DATA_COORDINATOR = "coordinator"

homeassistant/components/watttime/sensor.py

@@ -1,7 +1,8 @@
 """Support for WattTime sensors."""
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, cast
+from collections.abc import Mapping
+from typing import Any, cast
 
 from homeassistant.components.sensor import (
     STATE_CLASS_MEASUREMENT,
@@ -27,6 +28,7 @@ from homeassistant.helpers.update_coordinator import (
 from .const import (
     CONF_BALANCING_AUTHORITY,
     CONF_BALANCING_AUTHORITY_ABBREV,
+    CONF_SHOW_ON_MAP,
     DATA_COORDINATOR,
     DOMAIN,
 )
@@ -64,7 +66,7 @@ async def async_setup_entry(
     coordinator = hass.data[DOMAIN][entry.entry_id][DATA_COORDINATOR]
     async_add_entities(
         [
-            RealtimeEmissionsSensor(coordinator, description)
+            RealtimeEmissionsSensor(coordinator, entry, description)
             for description in REALTIME_EMISSIONS_SENSOR_DESCRIPTIONS
             if description.key in coordinator.data
         ]
@@ -77,26 +79,40 @@ class RealtimeEmissionsSensor(CoordinatorEntity, SensorEntity):
     def __init__(
         self,
         coordinator: DataUpdateCoordinator,
+        entry: ConfigEntry,
         description: SensorEntityDescription,
     ) -> None:
         """Initialize the sensor."""
         super().__init__(coordinator)
 
-        if TYPE_CHECKING:
+        self._attr_name = (
-            assert coordinator.config_entry
+            f"{description.name} ({entry.data[CONF_BALANCING_AUTHORITY_ABBREV]})"
-
+        )
-        self._attr_extra_state_attributes = {
+        self._attr_unique_id = f"{entry.entry_id}_{description.key}"
-            ATTR_ATTRIBUTION: DEFAULT_ATTRIBUTION,
+        self._entry = entry
-            ATTR_BALANCING_AUTHORITY: coordinator.config_entry.data[
-                CONF_BALANCING_AUTHORITY
-            ],
-            ATTR_LATITUDE: coordinator.config_entry.data[ATTR_LATITUDE],
-            ATTR_LONGITUDE: coordinator.config_entry.data[ATTR_LONGITUDE],
-        }
-        self._attr_name = f"{description.name} ({coordinator.config_entry.data[CONF_BALANCING_AUTHORITY_ABBREV]})"
-        self._attr_unique_id = f"{coordinator.config_entry.entry_id}_{description.key}"
         self.entity_description = description
 
+    @property
+    def extra_state_attributes(self) -> Mapping[str, Any] | None:
+        """Return entity specific state attributes."""
+        attrs = {
+            ATTR_ATTRIBUTION: DEFAULT_ATTRIBUTION,
+            ATTR_BALANCING_AUTHORITY: self._entry.data[CONF_BALANCING_AUTHORITY],
+        }
+
+        # Displaying the geography on the map relies upon putting the latitude/longitude
+        # in the entity attributes with "latitude" and "longitude" as the keys.
+        # Conversely, we can hide the location on the map by using other keys, like
+        # "lati" and "long".
+        if self._entry.options.get(CONF_SHOW_ON_MAP) is not False:
+            attrs[ATTR_LATITUDE] = self._entry.data[ATTR_LATITUDE]
+            attrs[ATTR_LONGITUDE] = self._entry.data[ATTR_LONGITUDE]
+        else:
+            attrs["lati"] = self._entry.data[ATTR_LATITUDE]
+            attrs["long"] = self._entry.data[ATTR_LONGITUDE]
+
+        return attrs
+
     @property
     def native_value(self) -> StateType:
         """Return the value reported by the sensor."""

homeassistant/components/watttime/strings.json

@@ -38,5 +38,15 @@
       "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
       "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]"
     }
+  },
+  "options": {
+    "step": {
+      "init": {
+        "title": "Configure WattTime",
+        "data": {
+          "show_on_map": "Show monitored location on the map"
+        }
+      }
+    }
   }
 }

homeassistant/components/watttime/translations/en.json

@@ -38,5 +38,15 @@
                 "description": "Input your username and password:"
             }
         }
+    },
+    "options": {
+        "step": {
+            "init": {
+                "data": {
+                    "show_on_map": "Show monitored location on the map"
+                },
+                "title": "Configure WattTime"
+            }
+        }
     }
 }

tests/components/watttime/test_config_flow.py

@@ -4,7 +4,7 @@ from unittest.mock import AsyncMock, patch
 from aiowatttime.errors import CoordinatesNotFoundError, InvalidCredentialsError
 import pytest
 
-from homeassistant import config_entries
+from homeassistant import config_entries, data_entry_flow
 from homeassistant.components.watttime.config_flow import (
     CONF_LOCATION_TYPE,
     LOCATION_TYPE_COORDINATES,
@@ -13,6 +13,7 @@ from homeassistant.components.watttime.config_flow import (
 from homeassistant.components.watttime.const import (
     CONF_BALANCING_AUTHORITY,
     CONF_BALANCING_AUTHORITY_ABBREV,
+    CONF_SHOW_ON_MAP,
     DOMAIN,
 )
 from homeassistant.const import (
@@ -77,12 +78,42 @@ async def test_duplicate_error(hass: HomeAssistant, client_login):
         result["flow_id"],
         user_input={CONF_LOCATION_TYPE: LOCATION_TYPE_HOME},
     )
-    await hass.async_block_till_done()
 
     assert result["type"] == RESULT_TYPE_ABORT
     assert result["reason"] == "already_configured"
 
 
+async def test_options_flow(hass):
+    """Test config flow options."""
+    entry = MockConfigEntry(
+        domain=DOMAIN,
+        unique_id="32.87336, -117.22743",
+        data={
+            CONF_USERNAME: "user",
+            CONF_PASSWORD: "password",
+            CONF_LATITUDE: 32.87336,
+            CONF_LONGITUDE: -117.22743,
+        },
+    )
+    entry.add_to_hass(hass)
+
+    with patch(
+        "homeassistant.components.watttime.async_setup_entry", return_value=True
+    ):
+        await hass.config_entries.async_setup(entry.entry_id)
+        result = await hass.config_entries.options.async_init(entry.entry_id)
+
+        assert result["type"] == data_entry_flow.RESULT_TYPE_FORM
+        assert result["step_id"] == "init"
+
+        result = await hass.config_entries.options.async_configure(
+            result["flow_id"], user_input={CONF_SHOW_ON_MAP: False}
+        )
+
+        assert result["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
+        assert entry.options == {CONF_SHOW_ON_MAP: False}
+
+
 async def test_show_form_coordinates(hass: HomeAssistant, client_login) -> None:
     """Test showing the form to input custom latitude/longitude."""
     result = await hass.config_entries.flow.async_init(
@@ -97,7 +128,6 @@ async def test_show_form_coordinates(hass: HomeAssistant, client_login) -> None:
         user_input={CONF_LOCATION_TYPE: LOCATION_TYPE_COORDINATES},
     )
     result = await hass.config_entries.flow.async_configure(result["flow_id"])
-    await hass.async_block_till_done()
 
     assert result["type"] == RESULT_TYPE_FORM
     assert result["step_id"] == "coordinates"
@@ -109,7 +139,6 @@ async def test_show_form_user(hass: HomeAssistant) -> None:
     result = await hass.config_entries.flow.async_init(
         DOMAIN, context={"source": config_entries.SOURCE_USER}
     )
-    await hass.async_block_till_done()
 
     assert result["type"] == RESULT_TYPE_FORM
     assert result["step_id"] == "user"
@@ -137,7 +166,6 @@ async def test_step_coordinates_unknown_coordinates(
         result["flow_id"],
         user_input={CONF_LATITUDE: "0", CONF_LONGITUDE: "0"},
     )
-    await hass.async_block_till_done()
 
     assert result["type"] == RESULT_TYPE_FORM
     assert result["errors"] == {"latitude": "unknown_coordinates"}
@@ -158,7 +186,6 @@ async def test_step_coordinates_unknown_error(
         result["flow_id"],
         user_input={CONF_LOCATION_TYPE: LOCATION_TYPE_HOME},
     )
-    await hass.async_block_till_done()
 
     assert result["type"] == RESULT_TYPE_FORM
     assert result["errors"] == {"base": "unknown"}
@@ -241,7 +268,6 @@ async def test_step_reauth_invalid_credentials(hass: HomeAssistant) -> None:
             result["flow_id"],
             user_input={CONF_PASSWORD: "password"},
         )
-        await hass.async_block_till_done()
 
     assert result["type"] == RESULT_TYPE_FORM
     assert result["errors"] == {"base": "invalid_auth"}
@@ -323,7 +349,6 @@ async def test_step_user_invalid_credentials(hass: HomeAssistant) -> None:
             context={"source": config_entries.SOURCE_USER},
             data={CONF_USERNAME: "user", CONF_PASSWORD: "password"},
         )
-        await hass.async_block_till_done()
 
     assert result["type"] == RESULT_TYPE_FORM
     assert result["errors"] == {"base": "invalid_auth"}
@@ -342,7 +367,6 @@ async def test_step_user_unknown_error(hass: HomeAssistant, client_login) -> Non
             context={"source": config_entries.SOURCE_USER},
             data={CONF_USERNAME: "user", CONF_PASSWORD: "password"},
         )
-        await hass.async_block_till_done()
 
     assert result["type"] == RESULT_TYPE_FORM
     assert result["errors"] == {"base": "unknown"}