Add config flow for Waze Travel Time

.coveragerc

@@ -1096,6 +1096,8 @@ omit =
     homeassistant/components/waterfurnace/*
     homeassistant/components/watson_iot/*
     homeassistant/components/watson_tts/tts.py
+    homeassistant/components/waze_travel_time/__init__.py
+    homeassistant/components/waze_travel_time/helpers.py
     homeassistant/components/waze_travel_time/sensor.py
     homeassistant/components/webostv/*
     homeassistant/components/whois/sensor.py

homeassistant/components/waze_travel_time/__init__.py

@@ -1 +1,29 @@
 """The waze_travel_time component."""
+import asyncio
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+
+PLATFORMS = ["sensor"]
+
+
+async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry) -> bool:
+    """Load the saved entities."""
+    for platform in PLATFORMS:
+        hass.async_create_task(
+            hass.config_entries.async_forward_entry_setup(config_entry, platform)
+        )
+
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, config_entry: ConfigEntry) -> bool:
+    """Unload a config entry."""
+    return all(
+        await asyncio.gather(
+            *[
+                hass.config_entries.async_forward_entry_unload(config_entry, platform)
+                for platform in PLATFORMS
+            ]
+        )
+    )

homeassistant/components/waze_travel_time/config_flow.py

@@ -0,0 +1,149 @@
+"""Config flow for Waze Travel Time integration."""
+import logging
+
+import voluptuous as vol
+
+from homeassistant import config_entries
+from homeassistant.const import CONF_NAME, CONF_REGION
+from homeassistant.core import callback
+import homeassistant.helpers.config_validation as cv
+from homeassistant.util import slugify
+
+from .const import (
+    CONF_AVOID_FERRIES,
+    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_NAME,
+    DOMAIN,
+    REGIONS,
+    UNITS,
+    VEHICLE_TYPES,
+)
+from .helpers import is_valid_config_entry
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class WazeOptionsFlow(config_entries.OptionsFlow):
+    """Handle an options flow for Waze Travel Time."""
+
+    def __init__(self, config_entry: config_entries.ConfigEntry) -> None:
+        """Initialize waze options flow."""
+        self.config_entry = config_entry
+
+    async def async_step_init(self, user_input=None):
+        """Handle the initial step."""
+        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.Optional(
+                        CONF_INCL_FILTER,
+                        default=self.config_entry.options.get(CONF_INCL_FILTER),
+                    ): cv.string,
+                    vol.Optional(
+                        CONF_EXCL_FILTER,
+                        default=self.config_entry.options.get(CONF_EXCL_FILTER),
+                    ): cv.string,
+                    vol.Optional(
+                        CONF_REALTIME,
+                        default=self.config_entry.options[CONF_REALTIME],
+                    ): cv.boolean,
+                    vol.Optional(
+                        CONF_VEHICLE_TYPE,
+                        default=self.config_entry.options[CONF_VEHICLE_TYPE],
+                    ): vol.In(VEHICLE_TYPES),
+                    vol.Optional(
+                        CONF_UNITS,
+                        default=self.config_entry.options[CONF_UNITS],
+                    ): vol.In(UNITS),
+                    vol.Optional(
+                        CONF_AVOID_TOLL_ROADS,
+                        default=self.config_entry.options[CONF_AVOID_TOLL_ROADS],
+                    ): cv.boolean,
+                    vol.Optional(
+                        CONF_AVOID_SUBSCRIPTION_ROADS,
+                        default=self.config_entry.options[
+                            CONF_AVOID_SUBSCRIPTION_ROADS
+                        ],
+                    ): cv.boolean,
+                    vol.Optional(
+                        CONF_AVOID_FERRIES,
+                        default=self.config_entry.options[CONF_AVOID_FERRIES],
+                    ): cv.boolean,
+                }
+            ),
+        )
+
+
+class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for Waze Travel Time."""
+
+    VERSION = 1
+    CONNECTION_CLASS = config_entries.CONN_CLASS_CLOUD_POLL
+
+    @staticmethod
+    @callback
+    def async_get_options_flow(
+        config_entry: config_entries.ConfigEntry,
+    ) -> WazeOptionsFlow:
+        """Get the options flow for this handler."""
+        return WazeOptionsFlow(config_entry)
+
+    async def async_step_user(self, user_input=None):
+        """Handle the initial step."""
+        errors = {}
+        if user_input is not None:
+            if await self.hass.async_add_executor_job(
+                is_valid_config_entry,
+                self.hass,
+                _LOGGER,
+                user_input[CONF_ORIGIN],
+                user_input[CONF_DESTINATION],
+                user_input[CONF_REGION],
+            ):
+                await self.async_set_unique_id(
+                    slugify(
+                        f"{DOMAIN}_{user_input[CONF_ORIGIN]}_{user_input[CONF_DESTINATION]}"
+                    )
+                )
+                self._abort_if_unique_id_configured()
+                return self.async_create_entry(
+                    title=(
+                        user_input.get(
+                            CONF_NAME,
+                            (
+                                f"{DEFAULT_NAME}: {user_input[CONF_ORIGIN]} -> "
+                                f"{user_input[CONF_DESTINATION]}"
+                            ),
+                        )
+                    ),
+                    data=user_input,
+                )
+
+            # If we get here, it's because we couldn't connect
+            errors["base"] = "cannot_connect"
+
+        return self.async_show_form(
+            step_id="user",
+            data_schema=vol.Schema(
+                {
+                    vol.Required(CONF_ORIGIN): cv.string,
+                    vol.Required(CONF_DESTINATION): cv.string,
+                    vol.Required(CONF_REGION): vol.In(REGIONS),
+                }
+            ),
+            errors=errors,
+        )
+
+    async_step_import = async_step_user

homeassistant/components/waze_travel_time/const.py

@@ -0,0 +1,40 @@
+"""Constants for waze_travel_time."""
+from homeassistant.const import CONF_UNIT_SYSTEM_IMPERIAL, CONF_UNIT_SYSTEM_METRIC
+
+DOMAIN = "waze_travel_time"
+
+ATTR_DESTINATION = "destination"
+ATTR_DURATION = "duration"
+ATTR_DISTANCE = "distance"
+ATTR_ORIGIN = "origin"
+ATTR_ROUTE = "route"
+
+ATTRIBUTION = "Powered by Waze"
+
+CONF_DESTINATION = "destination"
+CONF_ORIGIN = "origin"
+CONF_INCL_FILTER = "incl_filter"
+CONF_EXCL_FILTER = "excl_filter"
+CONF_REALTIME = "realtime"
+CONF_UNITS = "units"
+CONF_VEHICLE_TYPE = "vehicle_type"
+CONF_AVOID_TOLL_ROADS = "avoid_toll_roads"
+CONF_AVOID_SUBSCRIPTION_ROADS = "avoid_subscription_roads"
+CONF_AVOID_FERRIES = "avoid_ferries"
+
+DEFAULT_NAME = "Waze Travel Time"
+DEFAULT_REALTIME = True
+DEFAULT_VEHICLE_TYPE = "car"
+DEFAULT_AVOID_TOLL_ROADS = False
+DEFAULT_AVOID_SUBSCRIPTION_ROADS = False
+DEFAULT_AVOID_FERRIES = False
+
+ICON = "mdi:car"
+
+UNITS = [CONF_UNIT_SYSTEM_METRIC, CONF_UNIT_SYSTEM_IMPERIAL]
+
+REGIONS = ["US", "NA", "EU", "IL", "AU"]
+VEHICLE_TYPES = ["car", "taxi", "motorcycle"]
+
+# Attempt to find entity_id without finding address with period.
+ENTITY_ID_PATTERN = "(?<![a-zA-Z0-9 ])[a-z_]+[.][a-zA-Z0-9_]+"

homeassistant/components/waze_travel_time/helpers.py

@@ -0,0 +1,72 @@
+"""Helpers for Waze Travel Time integration."""
+import re
+
+from WazeRouteCalculator import WazeRouteCalculator, WRCError
+
+from homeassistant.components.waze_travel_time.const import ENTITY_ID_PATTERN
+from homeassistant.const import ATTR_LATITUDE, ATTR_LONGITUDE
+from homeassistant.helpers import location
+
+
+def is_valid_config_entry(hass, logger, origin, destination, region):
+    """Return whether the config entry data is valid."""
+    origin = resolve_location(hass, logger, origin)
+    destination = resolve_location(hass, logger, destination)
+    try:
+        WazeRouteCalculator(origin, destination, region).calc_all_routes_info()
+    except WRCError:
+        return False
+    return True
+
+
+def resolve_location(hass, logger, loc):
+    """Resolve a location."""
+    if re.fullmatch(ENTITY_ID_PATTERN, loc):
+        return get_location_from_entity(hass, logger, loc)
+
+    return resolve_zone(hass, loc)
+
+
+def get_location_from_entity(hass, logger, entity_id):
+    """Get the location from the entity_id."""
+    state = hass.states.get(entity_id)
+
+    if state is None:
+        logger.error("Unable to find entity %s", entity_id)
+        return None
+
+    # Check if the entity has location attributes.
+    if location.has_location(state):
+        logger.debug("Getting %s location", entity_id)
+        return _get_location_from_attributes(state)
+
+    # Check if device is inside a zone.
+    zone_state = hass.states.get(f"zone.{state.state}")
+    if location.has_location(zone_state):
+        logger.debug(
+            "%s is in %s, getting zone location", entity_id, zone_state.entity_id
+        )
+        return _get_location_from_attributes(zone_state)
+
+    # If zone was not found in state then use the state as the location.
+    if entity_id.startswith("sensor."):
+        return state.state
+
+    # When everything fails just return nothing.
+    return None
+
+
+def resolve_zone(hass, friendly_name):
+    """Get a lat/long from a zones friendly_name."""
+    states = hass.states.all()
+    for state in states:
+        if state.domain == "zone" and state.name == friendly_name:
+            return _get_location_from_attributes(state)
+
+    return friendly_name
+
+
+def _get_location_from_attributes(state):
+    """Get the lat/long string from an states attributes."""
+    attr = state.attributes
+    return "{},{}".format(attr.get(ATTR_LATITUDE), attr.get(ATTR_LONGITUDE))

homeassistant/components/waze_travel_time/manifest.json

@@ -2,6 +2,9 @@
   "domain": "waze_travel_time",
   "name": "Waze Travel Time",
   "documentation": "https://www.home-assistant.io/integrations/waze_travel_time",
-  "requirements": ["WazeRouteCalculator==0.12"],
-  "codeowners": []
+  "requirements": [
+    "WazeRouteCalculator==0.12"
+  ],
+  "codeowners": [],
+  "config_flow": true
 }