Allow waze_travel_time multiple excl/incl filter (#117252)

* Allow multiple excl/incl filter

* Use list comprehension for should_include

* Do not use mutable object as default param

* Inline migration func

homeassistant/components/waze_travel_time/__init__.py

@@ -1,6 +1,7 @@
 """The waze_travel_time component."""
 
 import asyncio
+from collections.abc import Collection
 import logging
 
 from pywaze.route_calculator import CalcRoutesResponse, WazeRouteCalculator, WRCError
@@ -28,10 +29,13 @@ from .const import (
     CONF_AVOID_SUBSCRIPTION_ROADS,
     CONF_AVOID_TOLL_ROADS,
     CONF_DESTINATION,
+    CONF_EXCL_FILTER,
+    CONF_INCL_FILTER,
     CONF_ORIGIN,
     CONF_REALTIME,
     CONF_UNITS,
     CONF_VEHICLE_TYPE,
+    DEFAULT_FILTER,
     DEFAULT_VEHICLE_TYPE,
     DOMAIN,
     METRIC_UNITS,
@@ -86,6 +90,7 @@ async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry) -> b
     """Load the saved entities."""
     if SEMAPHORE not in hass.data.setdefault(DOMAIN, {}):
         hass.data.setdefault(DOMAIN, {})[SEMAPHORE] = asyncio.Semaphore(1)
+
     await hass.config_entries.async_forward_entry_setups(config_entry, PLATFORMS)
 
     async def async_get_travel_times_service(service: ServiceCall) -> ServiceResponse:
@@ -124,11 +129,14 @@ async def async_get_travel_times(
     avoid_subscription_roads: bool,
     avoid_ferries: bool,
     realtime: bool,
-    incl_filter: str | None = None,
+    incl_filters: Collection[str] | None = None,
-    excl_filter: str | None = None,
+    excl_filters: Collection[str] | None = None,
 ) -> list[CalcRoutesResponse] | None:
     """Get all available routes."""
 
+    incl_filters = incl_filters or ()
+    excl_filters = excl_filters or ()
+
     _LOGGER.debug(
         "Getting update for origin: %s destination: %s",
         origin,
@@ -147,28 +155,46 @@ async def async_get_travel_times(
             real_time=realtime,
             alternatives=3,
         )
+        _LOGGER.debug("Got routes: %s", routes)
 
-        if incl_filter not in {None, ""}:
+        incl_routes: list[CalcRoutesResponse] = []
-            routes = [
+
-                r
+        def should_include_route(route: CalcRoutesResponse) -> bool:
-                for r in routes
+            if len(incl_filters) < 1:
-                if any(
+                return True
-                    incl_filter.lower() == street_name.lower()  # type: ignore[union-attr]
+            should_include = any(
-                    for street_name in r.street_names
+                street_name in incl_filters or "" in incl_filters
+                for street_name in route.street_names
+            )
+            if not should_include:
+                _LOGGER.debug(
+                    "Excluding route [%s], because no inclusive filter matched any streetname",
+                    route.name,
                 )
-            ]
+                return False
+            return True
 
-        if excl_filter not in {None, ""}:
+        incl_routes = [route for route in routes if should_include_route(route)]
-            routes = [
-                r
-                for r in routes
-                if not any(
-                    excl_filter.lower() == street_name.lower()  # type: ignore[union-attr]
-                    for street_name in r.street_names
-                )
-            ]
 
-        if len(routes) < 1:
+        filtered_routes: list[CalcRoutesResponse] = []
+
+        def should_exclude_route(route: CalcRoutesResponse) -> bool:
+            for street_name in route.street_names:
+                for excl_filter in excl_filters:
+                    if excl_filter == street_name:
+                        _LOGGER.debug(
+                            "Excluding route, because exclusive filter [%s] matched streetname: %s",
+                            excl_filter,
+                            route.name,
+                        )
+                        return True
+            return False
+
+        filtered_routes = [
+            route for route in incl_routes if not should_exclude_route(route)
+        ]
+
+        if len(filtered_routes) < 1:
             _LOGGER.warning("No routes found")
             return None
     except WRCError as exp:
@@ -176,9 +202,36 @@ async def async_get_travel_times(
         return None
 
     else:
-        return routes
+        return filtered_routes
 
 
 async def async_unload_entry(hass: HomeAssistant, config_entry: ConfigEntry) -> bool:
     """Unload a config entry."""
     return await hass.config_entries.async_unload_platforms(config_entry, PLATFORMS)
+
+
+async def async_migrate_entry(hass: HomeAssistant, config_entry: ConfigEntry) -> bool:
+    """Migrate an old config entry."""
+
+    if config_entry.version == 1:
+        _LOGGER.debug(
+            "Migrating from version %s.%s",
+            config_entry.version,
+            config_entry.minor_version,
+        )
+        options = dict(config_entry.options)
+        if (incl_filters := options.pop(CONF_INCL_FILTER, None)) not in {None, ""}:
+            options[CONF_INCL_FILTER] = [incl_filters]
+        else:
+            options[CONF_INCL_FILTER] = DEFAULT_FILTER
+        if (excl_filters := options.pop(CONF_EXCL_FILTER, None)) not in {None, ""}:
+            options[CONF_EXCL_FILTER] = [excl_filters]
+        else:
+            options[CONF_EXCL_FILTER] = DEFAULT_FILTER
+        hass.config_entries.async_update_entry(config_entry, options=options, version=2)
+        _LOGGER.debug(
+            "Migration to version %s.%s successful",
+            config_entry.version,
+            config_entry.minor_version,
+        )
+    return True

homeassistant/components/waze_travel_time/config_flow.py

@@ -20,6 +20,8 @@ from homeassistant.helpers.selector import (
     SelectSelectorConfig,
     SelectSelectorMode,
     TextSelector,
+    TextSelectorConfig,
+    TextSelectorType,
 )
 from homeassistant.util.unit_system import US_CUSTOMARY_SYSTEM
 
@@ -34,6 +36,7 @@ from .const import (
     CONF_REALTIME,
     CONF_UNITS,
     CONF_VEHICLE_TYPE,
+    DEFAULT_FILTER,
     DEFAULT_NAME,
     DEFAULT_OPTIONS,
     DOMAIN,
@@ -46,8 +49,18 @@ from .helpers import is_valid_config_entry
 
 OPTIONS_SCHEMA = vol.Schema(
     {
-        vol.Optional(CONF_INCL_FILTER, default=""): TextSelector(),
+        vol.Optional(CONF_INCL_FILTER): TextSelector(
-        vol.Optional(CONF_EXCL_FILTER, default=""): TextSelector(),
+            TextSelectorConfig(
+                type=TextSelectorType.TEXT,
+                multiple=True,
+            ),
+        ),
+        vol.Optional(CONF_EXCL_FILTER): TextSelector(
+            TextSelectorConfig(
+                type=TextSelectorType.TEXT,
+                multiple=True,
+            ),
+        ),
         vol.Optional(CONF_REALTIME): BooleanSelector(),
         vol.Required(CONF_VEHICLE_TYPE): SelectSelector(
             SelectSelectorConfig(
@@ -88,7 +101,7 @@ CONFIG_SCHEMA = vol.Schema(
 )
 
 
-def default_options(hass: HomeAssistant) -> dict[str, str | bool]:
+def default_options(hass: HomeAssistant) -> dict[str, str | bool | list[str]]:
     """Get the default options."""
     defaults = DEFAULT_OPTIONS.copy()
     if hass.config.units is US_CUSTOMARY_SYSTEM:
@@ -106,6 +119,10 @@ class WazeOptionsFlow(OptionsFlow):
     async def async_step_init(self, user_input=None) -> ConfigFlowResult:
         """Handle the initial step."""
         if user_input is not None:
+            if user_input.get(CONF_INCL_FILTER) is None:
+                user_input[CONF_INCL_FILTER] = DEFAULT_FILTER
+            if user_input.get(CONF_EXCL_FILTER) is None:
+                user_input[CONF_EXCL_FILTER] = DEFAULT_FILTER
             return self.async_create_entry(
                 title="",
                 data=user_input,
@@ -122,7 +139,7 @@ class WazeOptionsFlow(OptionsFlow):
 class WazeConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Waze Travel Time."""
 
-    VERSION = 1
+    VERSION = 2
 
     def __init__(self) -> None:
         """Init Config Flow."""

homeassistant/components/waze_travel_time/const.py

@@ -22,6 +22,7 @@ DEFAULT_VEHICLE_TYPE = "car"
 DEFAULT_AVOID_TOLL_ROADS = False
 DEFAULT_AVOID_SUBSCRIPTION_ROADS = False
 DEFAULT_AVOID_FERRIES = False
+DEFAULT_FILTER = [""]
 
 IMPERIAL_UNITS = "imperial"
 METRIC_UNITS = "metric"
@@ -30,11 +31,13 @@ UNITS = [METRIC_UNITS, IMPERIAL_UNITS]
 REGIONS = ["us", "na", "eu", "il", "au"]
 VEHICLE_TYPES = ["car", "taxi", "motorcycle"]
 
-DEFAULT_OPTIONS: dict[str, str | bool] = {
+DEFAULT_OPTIONS: dict[str, str | bool | list[str]] = {
     CONF_REALTIME: DEFAULT_REALTIME,
     CONF_VEHICLE_TYPE: DEFAULT_VEHICLE_TYPE,
     CONF_UNITS: METRIC_UNITS,
     CONF_AVOID_FERRIES: DEFAULT_AVOID_FERRIES,
     CONF_AVOID_SUBSCRIPTION_ROADS: DEFAULT_AVOID_SUBSCRIPTION_ROADS,
     CONF_AVOID_TOLL_ROADS: DEFAULT_AVOID_TOLL_ROADS,
+    CONF_INCL_FILTER: DEFAULT_FILTER,
+    CONF_EXCL_FILTER: DEFAULT_FILTER,
 }

homeassistant/components/waze_travel_time/sensor.py

@@ -183,8 +183,8 @@ class WazeTravelTimeData:
         )
         if self.origin is not None and self.destination is not None:
             # Grab options on every update
-            incl_filter = self.config_entry.options.get(CONF_INCL_FILTER)
+            incl_filter = self.config_entry.options[CONF_INCL_FILTER]
-            excl_filter = self.config_entry.options.get(CONF_EXCL_FILTER)
+            excl_filter = self.config_entry.options[CONF_EXCL_FILTER]
             realtime = self.config_entry.options[CONF_REALTIME]
             vehicle_type = self.config_entry.options[CONF_VEHICLE_TYPE]
             avoid_toll_roads = self.config_entry.options[CONF_AVOID_TOLL_ROADS]

tests/components/waze_travel_time/conftest.py

@@ -5,6 +5,7 @@ from unittest.mock import patch
 import pytest
 from pywaze.route_calculator import CalcRoutesResponse, WRCError
 
+from homeassistant.components.waze_travel_time.config_flow import WazeConfigFlow
 from homeassistant.components.waze_travel_time.const import DOMAIN
 from homeassistant.core import HomeAssistant
 
@@ -19,6 +20,7 @@ async def mock_config_fixture(hass: HomeAssistant, data, options):
         data=data,
         options=options,
         entry_id="test",
+        version=WazeConfigFlow.VERSION,
     )
     config_entry.add_to_hass(hass)
     await hass.config_entries.async_setup(config_entry.entry_id)

tests/components/waze_travel_time/test_config_flow.py

@@ -3,6 +3,7 @@
 import pytest
 
 from homeassistant import config_entries
+from homeassistant.components.waze_travel_time.config_flow import WazeConfigFlow
 from homeassistant.components.waze_travel_time.const import (
     CONF_AVOID_FERRIES,
     CONF_AVOID_SUBSCRIPTION_ROADS,
@@ -60,6 +61,7 @@ async def test_reconfigure(hass: HomeAssistant) -> None:
         domain=DOMAIN,
         data=MOCK_CONFIG,
         options=DEFAULT_OPTIONS,
+        version=WazeConfigFlow.VERSION,
     )
     entry.add_to_hass(hass)
     await hass.config_entries.async_setup(entry.entry_id)
@@ -103,6 +105,7 @@ async def test_options(hass: HomeAssistant) -> None:
         domain=DOMAIN,
         data=MOCK_CONFIG,
         options=DEFAULT_OPTIONS,
+        version=WazeConfigFlow.VERSION,
     )
     entry.add_to_hass(hass)
     await hass.config_entries.async_setup(entry.entry_id)
@@ -119,8 +122,8 @@ async def test_options(hass: HomeAssistant) -> None:
             CONF_AVOID_FERRIES: True,
             CONF_AVOID_SUBSCRIPTION_ROADS: True,
             CONF_AVOID_TOLL_ROADS: True,
-            CONF_EXCL_FILTER: "exclude",
+            CONF_EXCL_FILTER: ["exclude"],
-            CONF_INCL_FILTER: "include",
+            CONF_INCL_FILTER: ["include"],
             CONF_REALTIME: False,
             CONF_UNITS: IMPERIAL_UNITS,
             CONF_VEHICLE_TYPE: "taxi",
@@ -132,8 +135,8 @@ async def test_options(hass: HomeAssistant) -> None:
         CONF_AVOID_FERRIES: True,
         CONF_AVOID_SUBSCRIPTION_ROADS: True,
         CONF_AVOID_TOLL_ROADS: True,
-        CONF_EXCL_FILTER: "exclude",
+        CONF_EXCL_FILTER: ["exclude"],
-        CONF_INCL_FILTER: "include",
+        CONF_INCL_FILTER: ["include"],
         CONF_REALTIME: False,
         CONF_UNITS: IMPERIAL_UNITS,
         CONF_VEHICLE_TYPE: "taxi",
@@ -143,8 +146,8 @@ async def test_options(hass: HomeAssistant) -> None:
         CONF_AVOID_FERRIES: True,
         CONF_AVOID_SUBSCRIPTION_ROADS: True,
         CONF_AVOID_TOLL_ROADS: True,
-        CONF_EXCL_FILTER: "exclude",
+        CONF_EXCL_FILTER: ["exclude"],
-        CONF_INCL_FILTER: "include",
+        CONF_INCL_FILTER: ["include"],
         CONF_REALTIME: False,
         CONF_UNITS: IMPERIAL_UNITS,
         CONF_VEHICLE_TYPE: "taxi",
@@ -209,10 +212,14 @@ async def test_invalid_config_entry(
 async def test_reset_filters(hass: HomeAssistant) -> None:
     """Test resetting inclusive and exclusive filters to empty string."""
     options = {**DEFAULT_OPTIONS}
-    options[CONF_INCL_FILTER] = "test"
+    options[CONF_INCL_FILTER] = ["test"]
-    options[CONF_EXCL_FILTER] = "test"
+    options[CONF_EXCL_FILTER] = ["test"]
     config_entry = MockConfigEntry(
-        domain=DOMAIN, data=MOCK_CONFIG, options=options, entry_id="test"
+        domain=DOMAIN,
+        data=MOCK_CONFIG,
+        options=options,
+        entry_id="test",
+        version=WazeConfigFlow.VERSION,
     )
     config_entry.add_to_hass(hass)
     await hass.config_entries.async_setup(config_entry.entry_id)
@@ -228,8 +235,6 @@ async def test_reset_filters(hass: HomeAssistant) -> None:
             CONF_AVOID_FERRIES: True,
             CONF_AVOID_SUBSCRIPTION_ROADS: True,
             CONF_AVOID_TOLL_ROADS: True,
-            CONF_EXCL_FILTER: "",
-            CONF_INCL_FILTER: "",
             CONF_REALTIME: False,
             CONF_UNITS: IMPERIAL_UNITS,
             CONF_VEHICLE_TYPE: "taxi",
@@ -240,8 +245,8 @@ async def test_reset_filters(hass: HomeAssistant) -> None:
         CONF_AVOID_FERRIES: True,
         CONF_AVOID_SUBSCRIPTION_ROADS: True,
         CONF_AVOID_TOLL_ROADS: True,
-        CONF_EXCL_FILTER: "",
+        CONF_EXCL_FILTER: [""],
-        CONF_INCL_FILTER: "",
+        CONF_INCL_FILTER: [""],
         CONF_REALTIME: False,
         CONF_UNITS: IMPERIAL_UNITS,
         CONF_VEHICLE_TYPE: "taxi",

tests/components/waze_travel_time/test_init.py

@@ -2,11 +2,32 @@
 
 import pytest
 
-from homeassistant.components.waze_travel_time.const import DEFAULT_OPTIONS
+from homeassistant.components.waze_travel_time.const import (
+    CONF_AVOID_FERRIES,
+    CONF_AVOID_SUBSCRIPTION_ROADS,
+    CONF_AVOID_TOLL_ROADS,
+    CONF_EXCL_FILTER,
+    CONF_INCL_FILTER,
+    CONF_REALTIME,
+    CONF_UNITS,
+    CONF_VEHICLE_TYPE,
+    DEFAULT_AVOID_FERRIES,
+    DEFAULT_AVOID_SUBSCRIPTION_ROADS,
+    DEFAULT_AVOID_TOLL_ROADS,
+    DEFAULT_FILTER,
+    DEFAULT_OPTIONS,
+    DEFAULT_REALTIME,
+    DEFAULT_VEHICLE_TYPE,
+    DOMAIN,
+    METRIC_UNITS,
+)
+from homeassistant.config_entries import ConfigEntryState
 from homeassistant.core import HomeAssistant
 
 from .const import MOCK_CONFIG
 
+from tests.common import MockConfigEntry
+
 
 @pytest.mark.parametrize(
     ("data", "options"),
@@ -43,3 +64,59 @@ async def test_service_get_travel_times(hass: HomeAssistant) -> None:
             },
         ]
     }
+
+
+@pytest.mark.usefixtures("mock_update")
+async def test_migrate_entry_v1_v2(hass: HomeAssistant) -> None:
+    """Test successful migration of entry data."""
+    mock_entry = MockConfigEntry(
+        domain=DOMAIN,
+        version=1,
+        data=MOCK_CONFIG,
+        options={
+            CONF_REALTIME: DEFAULT_REALTIME,
+            CONF_VEHICLE_TYPE: DEFAULT_VEHICLE_TYPE,
+            CONF_UNITS: METRIC_UNITS,
+            CONF_AVOID_FERRIES: DEFAULT_AVOID_FERRIES,
+            CONF_AVOID_SUBSCRIPTION_ROADS: DEFAULT_AVOID_SUBSCRIPTION_ROADS,
+            CONF_AVOID_TOLL_ROADS: DEFAULT_AVOID_TOLL_ROADS,
+        },
+    )
+
+    mock_entry.add_to_hass(hass)
+    await hass.config_entries.async_setup(mock_entry.entry_id)
+    await hass.async_block_till_done()
+
+    updated_entry = hass.config_entries.async_get_entry(mock_entry.entry_id)
+
+    assert updated_entry.state is ConfigEntryState.LOADED
+    assert updated_entry.version == 2
+    assert updated_entry.options[CONF_INCL_FILTER] == DEFAULT_FILTER
+    assert updated_entry.options[CONF_EXCL_FILTER] == DEFAULT_FILTER
+
+    mock_entry = MockConfigEntry(
+        domain=DOMAIN,
+        version=1,
+        data=MOCK_CONFIG,
+        options={
+            CONF_REALTIME: DEFAULT_REALTIME,
+            CONF_VEHICLE_TYPE: DEFAULT_VEHICLE_TYPE,
+            CONF_UNITS: METRIC_UNITS,
+            CONF_AVOID_FERRIES: DEFAULT_AVOID_FERRIES,
+            CONF_AVOID_SUBSCRIPTION_ROADS: DEFAULT_AVOID_SUBSCRIPTION_ROADS,
+            CONF_AVOID_TOLL_ROADS: DEFAULT_AVOID_TOLL_ROADS,
+            CONF_INCL_FILTER: "include",
+            CONF_EXCL_FILTER: "exclude",
+        },
+    )
+
+    mock_entry.add_to_hass(hass)
+    await hass.config_entries.async_setup(mock_entry.entry_id)
+    await hass.async_block_till_done()
+
+    updated_entry = hass.config_entries.async_get_entry(mock_entry.entry_id)
+
+    assert updated_entry.state is ConfigEntryState.LOADED
+    assert updated_entry.version == 2
+    assert updated_entry.options[CONF_INCL_FILTER] == ["include"]
+    assert updated_entry.options[CONF_EXCL_FILTER] == ["exclude"]

tests/components/waze_travel_time/test_sensor.py

@@ -3,6 +3,7 @@
 import pytest
 from pywaze.route_calculator import WRCError
 
+from homeassistant.components.waze_travel_time.config_flow import WazeConfigFlow
 from homeassistant.components.waze_travel_time.const import (
     CONF_AVOID_FERRIES,
     CONF_AVOID_SUBSCRIPTION_ROADS,
@@ -74,6 +75,8 @@ async def test_sensor(hass: HomeAssistant) -> None:
                 CONF_AVOID_TOLL_ROADS: True,
                 CONF_AVOID_SUBSCRIPTION_ROADS: True,
                 CONF_AVOID_FERRIES: True,
+                CONF_INCL_FILTER: [""],
+                CONF_EXCL_FILTER: [""],
             },
         )
     ],
@@ -98,7 +101,8 @@ async def test_imperial(hass: HomeAssistant) -> None:
                 CONF_AVOID_TOLL_ROADS: True,
                 CONF_AVOID_SUBSCRIPTION_ROADS: True,
                 CONF_AVOID_FERRIES: True,
-                CONF_INCL_FILTER: "IncludeThis",
+                CONF_INCL_FILTER: ["IncludeThis"],
+                CONF_EXCL_FILTER: [""],
             },
         )
     ],
@@ -121,7 +125,8 @@ async def test_incl_filter(hass: HomeAssistant) -> None:
                 CONF_AVOID_TOLL_ROADS: True,
                 CONF_AVOID_SUBSCRIPTION_ROADS: True,
                 CONF_AVOID_FERRIES: True,
-                CONF_EXCL_FILTER: "ExcludeThis",
+                CONF_INCL_FILTER: [""],
+                CONF_EXCL_FILTER: ["ExcludeThis"],
             },
         )
     ],
@@ -138,7 +143,11 @@ async def test_sensor_failed_wrcerror(
 ) -> None:
     """Test that sensor update fails with log message."""
     config_entry = MockConfigEntry(
-        domain=DOMAIN, data=MOCK_CONFIG, options=DEFAULT_OPTIONS, entry_id="test"
+        domain=DOMAIN,
+        data=MOCK_CONFIG,
+        options=DEFAULT_OPTIONS,
+        entry_id="test",
+        version=WazeConfigFlow.VERSION,
     )
     config_entry.add_to_hass(hass)
     await hass.config_entries.async_setup(config_entry.entry_id)