From 1c534ea027b4b5b31d9affcab3a250d2cf425967 Mon Sep 17 00:00:00 2001
From: Franck Nijhof <git@frenck.dev>
Date: Wed, 30 Sep 2020 21:24:57 +0200
Subject: [PATCH 01/82] Bumped version to 0.116.0b0

---
 homeassistant/const.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/homeassistant/const.py b/homeassistant/const.py
index f845bc2bd0f..a641b43e9fb 100644
--- a/homeassistant/const.py
+++ b/homeassistant/const.py
@@ -1,7 +1,7 @@
 """Constants used by Home Assistant components."""
 MAJOR_VERSION = 0
 MINOR_VERSION = 116
-PATCH_VERSION = "0.dev0"
+PATCH_VERSION = "0b0"
 __short_version__ = f"{MAJOR_VERSION}.{MINOR_VERSION}"
 __version__ = f"{__short_version__}.{PATCH_VERSION}"
 REQUIRED_PYTHON_VER = (3, 7, 1)

From b9931aabe72adc47c9aa1a0d69379b26ff37339d Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Thu, 1 Oct 2020 03:19:20 -0500
Subject: [PATCH 02/82] Seperate state change tracking from
 async_track_template_result into async_track_state_change_filtered (#40803)

---
 homeassistant/helpers/event.py | 334 +++++++++++++++++++++------------
 tests/helpers/test_event.py    | 138 ++++++++++++++
 2 files changed, 349 insertions(+), 123 deletions(-)

diff --git a/homeassistant/helpers/event.py b/homeassistant/helpers/event.py
index 9af781b7abd..b396ebb1d91 100644
--- a/homeassistant/helpers/event.py
+++ b/homeassistant/helpers/event.py
@@ -61,13 +61,27 @@ TRACK_STATE_REMOVED_DOMAIN_LISTENER = "track_state_removed_domain_listener"
 TRACK_ENTITY_REGISTRY_UPDATED_CALLBACKS = "track_entity_registry_updated_callbacks"
 TRACK_ENTITY_REGISTRY_UPDATED_LISTENER = "track_entity_registry_updated_listener"
 
-_TEMPLATE_ALL_LISTENER = "all"
-_TEMPLATE_DOMAINS_LISTENER = "domains"
-_TEMPLATE_ENTITIES_LISTENER = "entities"
+_ALL_LISTENER = "all"
+_DOMAINS_LISTENER = "domains"
+_ENTITIES_LISTENER = "entities"
 
 _LOGGER = logging.getLogger(__name__)
 
 
+@dataclass
+class TrackStates:
+    """Class for keeping track of states being tracked.
+
+    all_states: All states on the system are being tracked
+    entities: Entities to track
+    domains: Domains to track
+    """
+
+    all_states: bool
+    entities: Set
+    domains: Set
+
+
 @dataclass
 class TrackTemplate:
     """Class for keeping track of a template with variables.
@@ -452,6 +466,158 @@ def _async_string_to_lower_list(instr: Union[str, Iterable[str]]) -> List[str]:
     return [mstr.lower() for mstr in instr]
 
 
+class _TrackStateChangeFiltered:
+    """Handle removal / refresh of tracker."""
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        track_states: TrackStates,
+        action: Callable[[Event], Any],
+    ):
+        """Handle removal / refresh of tracker init."""
+        self.hass = hass
+        self._action = action
+        self._listeners: Dict[str, Callable] = {}
+        self._last_track_states: TrackStates = track_states
+
+    @callback
+    def async_setup(self) -> None:
+        """Create listeners to track states."""
+        track_states = self._last_track_states
+
+        if (
+            not track_states.all_states
+            and not track_states.domains
+            and not track_states.entities
+        ):
+            return
+
+        if track_states.all_states:
+            self._setup_all_listener()
+            return
+
+        self._setup_domains_listener(track_states.domains)
+        self._setup_entities_listener(track_states.domains, track_states.entities)
+
+    @property
+    def listeners(self) -> Dict:
+        """State changes that will cause a re-render."""
+        track_states = self._last_track_states
+        return {
+            _ALL_LISTENER: track_states.all_states,
+            _ENTITIES_LISTENER: track_states.entities,
+            _DOMAINS_LISTENER: track_states.domains,
+        }
+
+    @callback
+    def async_update_listeners(self, new_track_states: TrackStates) -> None:
+        """Update the listeners based on the new TrackStates."""
+        last_track_states = self._last_track_states
+        self._last_track_states = new_track_states
+
+        had_all_listener = last_track_states.all_states
+
+        if new_track_states.all_states:
+            if had_all_listener:
+                return
+            self._cancel_listener(_DOMAINS_LISTENER)
+            self._cancel_listener(_ENTITIES_LISTENER)
+            self._setup_all_listener()
+            return
+
+        if had_all_listener:
+            self._cancel_listener(_ALL_LISTENER)
+
+        domains_changed = new_track_states.domains != last_track_states.domains
+
+        if had_all_listener or domains_changed:
+            domains_changed = True
+            self._cancel_listener(_DOMAINS_LISTENER)
+            self._setup_domains_listener(new_track_states.domains)
+
+        if (
+            had_all_listener
+            or domains_changed
+            or new_track_states.entities != last_track_states.entities
+        ):
+            self._cancel_listener(_ENTITIES_LISTENER)
+            self._setup_entities_listener(
+                new_track_states.domains, new_track_states.entities
+            )
+
+    @callback
+    def async_remove(self) -> None:
+        """Cancel the listeners."""
+        for key in list(self._listeners):
+            self._listeners.pop(key)()
+
+    @callback
+    def _cancel_listener(self, listener_name: str) -> None:
+        if listener_name not in self._listeners:
+            return
+
+        self._listeners.pop(listener_name)()
+
+    @callback
+    def _setup_entities_listener(self, domains: Set, entities: Set) -> None:
+        if domains:
+            entities = entities.copy()
+            entities.update(self.hass.states.async_entity_ids(domains))
+
+        # Entities has changed to none
+        if not entities:
+            return
+
+        self._listeners[_ENTITIES_LISTENER] = async_track_state_change_event(
+            self.hass, entities, self._action
+        )
+
+    @callback
+    def _setup_domains_listener(self, domains: Set) -> None:
+        if not domains:
+            return
+
+        self._listeners[_DOMAINS_LISTENER] = async_track_state_added_domain(
+            self.hass, domains, self._action
+        )
+
+    @callback
+    def _setup_all_listener(self) -> None:
+        self._listeners[_ALL_LISTENER] = self.hass.bus.async_listen(
+            EVENT_STATE_CHANGED, self._action
+        )
+
+
+@callback
+@bind_hass
+def async_track_state_change_filtered(
+    hass: HomeAssistant,
+    track_states: TrackStates,
+    action: Callable[[Event], Any],
+) -> _TrackStateChangeFiltered:
+    """Track state changes with a TrackStates filter that can be updated.
+
+    Parameters
+    ----------
+    hass
+        Home assistant object.
+    track_states
+        A TrackStates data class.
+    action
+        Callable to call with results.
+
+    Returns
+    -------
+    Object used to update the listeners (async_update_listeners) with a new TrackStates or
+    cancel the tracking (async_remove).
+
+    """
+    tracker = _TrackStateChangeFiltered(hass, track_states, action)
+    tracker.async_setup()
+    return tracker
+
+
 @callback
 @bind_hass
 def async_track_template(
@@ -557,12 +723,9 @@ class _TrackTemplateResultInfo:
             track_template_.template.hass = hass
         self._track_templates = track_templates
 
-        self._listeners: Dict[str, Callable] = {}
-
         self._last_result: Dict[Template, Union[str, TemplateError]] = {}
         self._info: Dict[Template, RenderInfo] = {}
-        self._last_domains: Set = set()
-        self._last_entities: Set = set()
+        self._track_state_changes: Optional[_TrackStateChangeFiltered] = None
 
     def async_setup(self, raise_on_template_error: bool) -> None:
         """Activation of template tracking."""
@@ -580,7 +743,9 @@ class _TrackTemplateResultInfo:
                     exc_info=self._info[template].exception,
                 )
 
-        self._create_listeners()
+        self._track_state_changes = async_track_state_change_filtered(
+            self.hass, _render_infos_to_track_states(self._info.values()), self._refresh
+        )
         _LOGGER.debug(
             "Template group %s listens for %s",
             self._track_templates,
@@ -590,123 +755,14 @@ class _TrackTemplateResultInfo:
     @property
     def listeners(self) -> Dict:
         """State changes that will cause a re-render."""
-        return {
-            "all": _TEMPLATE_ALL_LISTENER in self._listeners,
-            "entities": self._last_entities,
-            "domains": self._last_domains,
-        }
-
-    @property
-    def _needs_all_listener(self) -> bool:
-        for info in self._info.values():
-            # Tracking all states
-            if info.all_states or info.all_states_lifecycle:
-                return True
-
-            # Previous call had an exception
-            # so we do not know which states
-            # to track
-            if info.exception:
-                return True
-
-        return False
-
-    @property
-    def _all_templates_are_static(self) -> bool:
-        for info in self._info.values():
-            if not info.is_static:
-                return False
-
-        return True
-
-    @callback
-    def _create_listeners(self) -> None:
-        if self._all_templates_are_static:
-            return
-
-        if self._needs_all_listener:
-            self._setup_all_listener()
-            return
-
-        self._last_entities, self._last_domains = _entities_domains_from_info(
-            self._info.values()
-        )
-        self._setup_domains_listener(self._last_domains)
-        self._setup_entities_listener(self._last_domains, self._last_entities)
-
-    @callback
-    def _cancel_listener(self, listener_name: str) -> None:
-        if listener_name not in self._listeners:
-            return
-
-        self._listeners.pop(listener_name)()
-
-    @callback
-    def _update_listeners(self) -> None:
-        had_all_listener = _TEMPLATE_ALL_LISTENER in self._listeners
-
-        if self._needs_all_listener:
-            if had_all_listener:
-                return
-            self._last_domains = set()
-            self._last_entities = set()
-            self._cancel_listener(_TEMPLATE_DOMAINS_LISTENER)
-            self._cancel_listener(_TEMPLATE_ENTITIES_LISTENER)
-            self._setup_all_listener()
-            return
-
-        if had_all_listener:
-            self._cancel_listener(_TEMPLATE_ALL_LISTENER)
-
-        entities, domains = _entities_domains_from_info(self._info.values())
-        domains_changed = domains != self._last_domains
-
-        if had_all_listener or domains_changed:
-            domains_changed = True
-            self._cancel_listener(_TEMPLATE_DOMAINS_LISTENER)
-            self._setup_domains_listener(domains)
-
-        if had_all_listener or domains_changed or entities != self._last_entities:
-            self._cancel_listener(_TEMPLATE_ENTITIES_LISTENER)
-            self._setup_entities_listener(domains, entities)
-
-        self._last_domains = domains
-        self._last_entities = entities
-
-    @callback
-    def _setup_entities_listener(self, domains: Set, entities: Set) -> None:
-        if domains:
-            entities = entities.copy()
-            entities.update(self.hass.states.async_entity_ids(domains))
-
-        # Entities has changed to none
-        if not entities:
-            return
-
-        self._listeners[_TEMPLATE_ENTITIES_LISTENER] = async_track_state_change_event(
-            self.hass, entities, self._refresh
-        )
-
-    @callback
-    def _setup_domains_listener(self, domains: Set) -> None:
-        if not domains:
-            return
-
-        self._listeners[_TEMPLATE_DOMAINS_LISTENER] = async_track_state_added_domain(
-            self.hass, domains, self._refresh
-        )
-
-    @callback
-    def _setup_all_listener(self) -> None:
-        self._listeners[_TEMPLATE_ALL_LISTENER] = self.hass.bus.async_listen(
-            EVENT_STATE_CHANGED, self._refresh
-        )
+        assert self._track_state_changes
+        return self._track_state_changes.listeners
 
     @callback
     def async_remove(self) -> None:
         """Cancel the listener."""
-        for key in list(self._listeners):
-            self._listeners.pop(key)()
+        assert self._track_state_changes
+        self._track_state_changes.async_remove()
 
     @callback
     def async_refresh(self) -> None:
@@ -765,7 +821,10 @@ class _TrackTemplateResultInfo:
             updates.append(TrackTemplateResult(template, last_result, result))
 
         if info_changed:
-            self._update_listeners()
+            assert self._track_state_changes
+            self._track_state_changes.async_update_listeners(
+                _render_infos_to_track_states(self._info.values()),
+            )
             _LOGGER.debug(
                 "Template group %s listens for %s",
                 self._track_templates,
@@ -1229,7 +1288,10 @@ def process_state_match(
     return lambda state: state in parameter_set
 
 
-def _entities_domains_from_info(render_infos: Iterable[RenderInfo]) -> Tuple[Set, Set]:
+@callback
+def _entities_domains_from_render_infos(
+    render_infos: Iterable[RenderInfo],
+) -> Tuple[Set, Set]:
     """Combine from multiple RenderInfo."""
     entities = set()
     domains = set()
@@ -1242,3 +1304,29 @@ def _entities_domains_from_info(render_infos: Iterable[RenderInfo]) -> Tuple[Set
         if render_info.domains_lifecycle:
             domains.update(render_info.domains_lifecycle)
     return entities, domains
+
+
+@callback
+def _render_infos_needs_all_listener(render_infos: Iterable[RenderInfo]) -> bool:
+    """Determine if an all listener is needed from RenderInfo."""
+    for render_info in render_infos:
+        # Tracking all states
+        if render_info.all_states or render_info.all_states_lifecycle:
+            return True
+
+        # Previous call had an exception
+        # so we do not know which states
+        # to track
+        if render_info.exception:
+            return True
+
+    return False
+
+
+@callback
+def _render_infos_to_track_states(render_infos: Iterable[RenderInfo]) -> TrackStates:
+    """Create a TrackStates dataclass from the latest RenderInfo."""
+    if _render_infos_needs_all_listener(render_infos):
+        return TrackStates(True, set(), set())
+
+    return TrackStates(False, *_entities_domains_from_render_infos(render_infos))
diff --git a/tests/helpers/test_event.py b/tests/helpers/test_event.py
index 8bdf9cb891c..887917fa74c 100644
--- a/tests/helpers/test_event.py
+++ b/tests/helpers/test_event.py
@@ -14,6 +14,7 @@ from homeassistant.core import callback
 from homeassistant.exceptions import TemplateError
 from homeassistant.helpers.entity_registry import EVENT_ENTITY_REGISTRY_UPDATED
 from homeassistant.helpers.event import (
+    TrackStates,
     TrackTemplate,
     TrackTemplateResult,
     async_call_later,
@@ -23,6 +24,7 @@ from homeassistant.helpers.event import (
     async_track_state_added_domain,
     async_track_state_change,
     async_track_state_change_event,
+    async_track_state_change_filtered,
     async_track_state_removed_domain,
     async_track_sunrise,
     async_track_sunset,
@@ -255,6 +257,142 @@ async def test_track_state_change(hass):
     assert len(wildercard_runs) == 6
 
 
+async def test_async_track_state_change_filtered(hass):
+    """Test async_track_state_change_filtered."""
+    single_entity_id_tracker = []
+    multiple_entity_id_tracker = []
+
+    @ha.callback
+    def single_run_callback(event):
+        old_state = event.data.get("old_state")
+        new_state = event.data.get("new_state")
+
+        single_entity_id_tracker.append((old_state, new_state))
+
+    @ha.callback
+    def multiple_run_callback(event):
+        old_state = event.data.get("old_state")
+        new_state = event.data.get("new_state")
+
+        multiple_entity_id_tracker.append((old_state, new_state))
+
+    @ha.callback
+    def callback_that_throws(event):
+        raise ValueError
+
+    track_single = async_track_state_change_filtered(
+        hass, TrackStates(False, {"light.bowl"}, None), single_run_callback
+    )
+    assert track_single.listeners == {
+        "all": False,
+        "domains": None,
+        "entities": {"light.bowl"},
+    }
+
+    track_multi = async_track_state_change_filtered(
+        hass, TrackStates(False, {"light.bowl"}, {"switch"}), multiple_run_callback
+    )
+    assert track_multi.listeners == {
+        "all": False,
+        "domains": {"switch"},
+        "entities": {"light.bowl"},
+    }
+
+    track_throws = async_track_state_change_filtered(
+        hass, TrackStates(False, {"light.bowl"}, {"switch"}), callback_that_throws
+    )
+    assert track_throws.listeners == {
+        "all": False,
+        "domains": {"switch"},
+        "entities": {"light.bowl"},
+    }
+
+    # Adding state to state machine
+    hass.states.async_set("light.Bowl", "on")
+    await hass.async_block_till_done()
+    assert len(single_entity_id_tracker) == 1
+    assert single_entity_id_tracker[-1][0] is None
+    assert single_entity_id_tracker[-1][1] is not None
+    assert len(multiple_entity_id_tracker) == 1
+    assert multiple_entity_id_tracker[-1][0] is None
+    assert multiple_entity_id_tracker[-1][1] is not None
+
+    # Set same state should not trigger a state change/listener
+    hass.states.async_set("light.Bowl", "on")
+    await hass.async_block_till_done()
+    assert len(single_entity_id_tracker) == 1
+    assert len(multiple_entity_id_tracker) == 1
+
+    # State change off -> on
+    hass.states.async_set("light.Bowl", "off")
+    await hass.async_block_till_done()
+    assert len(single_entity_id_tracker) == 2
+    assert len(multiple_entity_id_tracker) == 2
+
+    # State change off -> off
+    hass.states.async_set("light.Bowl", "off", {"some_attr": 1})
+    await hass.async_block_till_done()
+    assert len(single_entity_id_tracker) == 3
+    assert len(multiple_entity_id_tracker) == 3
+
+    # State change off -> on
+    hass.states.async_set("light.Bowl", "on")
+    await hass.async_block_till_done()
+    assert len(single_entity_id_tracker) == 4
+    assert len(multiple_entity_id_tracker) == 4
+
+    hass.states.async_remove("light.bowl")
+    await hass.async_block_till_done()
+    assert len(single_entity_id_tracker) == 5
+    assert single_entity_id_tracker[-1][0] is not None
+    assert single_entity_id_tracker[-1][1] is None
+    assert len(multiple_entity_id_tracker) == 5
+    assert multiple_entity_id_tracker[-1][0] is not None
+    assert multiple_entity_id_tracker[-1][1] is None
+
+    # Set state for different entity id
+    hass.states.async_set("switch.kitchen", "on")
+    await hass.async_block_till_done()
+    assert len(single_entity_id_tracker) == 5
+    assert len(multiple_entity_id_tracker) == 6
+
+    track_single.async_remove()
+    # Ensure unsubing the listener works
+    hass.states.async_set("light.Bowl", "off")
+    await hass.async_block_till_done()
+    assert len(single_entity_id_tracker) == 5
+    assert len(multiple_entity_id_tracker) == 7
+
+    assert track_multi.listeners == {
+        "all": False,
+        "domains": {"switch"},
+        "entities": {"light.bowl"},
+    }
+    track_multi.async_update_listeners(TrackStates(False, {"light.bowl"}, None))
+    assert track_multi.listeners == {
+        "all": False,
+        "domains": None,
+        "entities": {"light.bowl"},
+    }
+    hass.states.async_set("light.Bowl", "on")
+    await hass.async_block_till_done()
+    assert len(multiple_entity_id_tracker) == 8
+    hass.states.async_set("switch.kitchen", "off")
+    await hass.async_block_till_done()
+    assert len(multiple_entity_id_tracker) == 8
+
+    track_multi.async_update_listeners(TrackStates(True, None, None))
+    hass.states.async_set("switch.kitchen", "off")
+    await hass.async_block_till_done()
+    assert len(multiple_entity_id_tracker) == 8
+    hass.states.async_set("switch.any", "off")
+    await hass.async_block_till_done()
+    assert len(multiple_entity_id_tracker) == 9
+
+    track_multi.async_remove()
+    track_throws.async_remove()
+
+
 async def test_async_track_state_change_event(hass):
     """Test async_track_state_change_event."""
     single_entity_id_tracker = []

From 0902caa7e4e1070342e7c7dd6ff1b95690e8e04d Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Thu, 1 Oct 2020 14:39:44 -0500
Subject: [PATCH 03/82] Implement template rate_limit directive (#40667)

---
 homeassistant/const.py                   |   4 +
 homeassistant/core.py                    |   2 +-
 homeassistant/helpers/event.py           |  24 +-
 homeassistant/helpers/ratelimit.py       |  97 +++++++
 homeassistant/helpers/template.py        |  44 ++-
 tests/components/template/test_cover.py  |   1 +
 tests/components/template/test_sensor.py |  16 +-
 tests/helpers/test_event.py              | 341 ++++++++++++++++++++++-
 tests/helpers/test_ratelimit.py          | 108 +++++++
 tests/helpers/test_template.py           |  50 +++-
 10 files changed, 669 insertions(+), 18 deletions(-)
 create mode 100644 homeassistant/helpers/ratelimit.py
 create mode 100644 tests/helpers/test_ratelimit.py

diff --git a/homeassistant/const.py b/homeassistant/const.py
index a641b43e9fb..98186047459 100644
--- a/homeassistant/const.py
+++ b/homeassistant/const.py
@@ -623,3 +623,7 @@ CLOUD_NEVER_EXPOSED_ENTITIES = ["group.all_locks"]
 
 # The ID of the Home Assistant Cast App
 CAST_APP_ID_HOMEASSISTANT = "B12CE3CA"
+
+# The tracker error allow when converting
+# loop time to human readable time
+MAX_TIME_TRACKING_ERROR = 0.001
diff --git a/homeassistant/core.py b/homeassistant/core.py
index eb584b22b49..82fbe1be2b6 100644
--- a/homeassistant/core.py
+++ b/homeassistant/core.py
@@ -538,7 +538,7 @@ class Event:
         event_type: str,
         data: Optional[Dict[str, Any]] = None,
         origin: EventOrigin = EventOrigin.local,
-        time_fired: Optional[int] = None,
+        time_fired: Optional[datetime.datetime] = None,
         context: Optional[Context] = None,
     ) -> None:
         """Initialize a new event."""
diff --git a/homeassistant/helpers/event.py b/homeassistant/helpers/event.py
index b396ebb1d91..52a43fca3ff 100644
--- a/homeassistant/helpers/event.py
+++ b/homeassistant/helpers/event.py
@@ -27,6 +27,7 @@ from homeassistant.const import (
     EVENT_STATE_CHANGED,
     EVENT_TIME_CHANGED,
     MATCH_ALL,
+    MAX_TIME_TRACKING_ERROR,
     SUN_EVENT_SUNRISE,
     SUN_EVENT_SUNSET,
 )
@@ -40,6 +41,7 @@ from homeassistant.core import (
 )
 from homeassistant.exceptions import TemplateError
 from homeassistant.helpers.entity_registry import EVENT_ENTITY_REGISTRY_UPDATED
+from homeassistant.helpers.ratelimit import KeyedRateLimit
 from homeassistant.helpers.sun import get_astral_event_next
 from homeassistant.helpers.template import RenderInfo, Template, result_as_boolean
 from homeassistant.helpers.typing import TemplateVarsType
@@ -47,8 +49,6 @@ from homeassistant.loader import bind_hass
 from homeassistant.util import dt as dt_util
 from homeassistant.util.async_ import run_callback_threadsafe
 
-MAX_TIME_TRACKING_ERROR = 0.001
-
 TRACK_STATE_CHANGE_CALLBACKS = "track_state_change_callbacks"
 TRACK_STATE_CHANGE_LISTENER = "track_state_change_listener"
 
@@ -88,10 +88,12 @@ class TrackTemplate:
 
     The template is template to calculate.
     The variables are variables to pass to the template.
+    The rate_limit is a rate limit on how often the template is re-rendered.
     """
 
     template: Template
     variables: TemplateVarsType
+    rate_limit: Optional[timedelta] = None
 
 
 @dataclass
@@ -724,6 +726,8 @@ class _TrackTemplateResultInfo:
         self._track_templates = track_templates
 
         self._last_result: Dict[Template, Union[str, TemplateError]] = {}
+
+        self._rate_limit = KeyedRateLimit(hass)
         self._info: Dict[Template, RenderInfo] = {}
         self._track_state_changes: Optional[_TrackStateChangeFiltered] = None
 
@@ -763,6 +767,7 @@ class _TrackTemplateResultInfo:
         """Cancel the listener."""
         assert self._track_state_changes
         self._track_state_changes.async_remove()
+        self._rate_limit.async_remove()
 
     @callback
     def async_refresh(self) -> None:
@@ -784,11 +789,23 @@ class _TrackTemplateResultInfo:
     def _refresh(self, event: Optional[Event]) -> None:
         updates = []
         info_changed = False
+        now = dt_util.utcnow()
 
         for track_template_ in self._track_templates:
             template = track_template_.template
             if event:
-                if not self._event_triggers_template(template, event):
+                if not self._rate_limit.async_has_timer(
+                    template
+                ) and not self._event_triggers_template(template, event):
+                    continue
+
+                if self._rate_limit.async_schedule_action(
+                    template,
+                    self._info[template].rate_limit or track_template_.rate_limit,
+                    now,
+                    self._refresh,
+                    event,
+                ):
                     continue
 
                 _LOGGER.debug(
@@ -797,6 +814,7 @@ class _TrackTemplateResultInfo:
                     event,
                 )
 
+            self._rate_limit.async_triggered(template, now)
             self._info[template] = template.async_render_to_info(
                 track_template_.variables
             )
diff --git a/homeassistant/helpers/ratelimit.py b/homeassistant/helpers/ratelimit.py
new file mode 100644
index 00000000000..422ebdf2eee
--- /dev/null
+++ b/homeassistant/helpers/ratelimit.py
@@ -0,0 +1,97 @@
+"""Ratelimit helper."""
+import asyncio
+from datetime import datetime, timedelta
+import logging
+from typing import Any, Callable, Dict, Hashable, Optional
+
+from homeassistant.const import MAX_TIME_TRACKING_ERROR
+from homeassistant.core import HomeAssistant, callback
+import homeassistant.util.dt as dt_util
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class KeyedRateLimit:
+    """Class to track rate limits."""
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+    ):
+        """Initialize ratelimit tracker."""
+        self.hass = hass
+        self._last_triggered: Dict[Hashable, datetime] = {}
+        self._rate_limit_timers: Dict[Hashable, asyncio.TimerHandle] = {}
+
+    @callback
+    def async_has_timer(self, key: Hashable) -> bool:
+        """Check if a rate limit timer is running."""
+        return key in self._rate_limit_timers
+
+    @callback
+    def async_triggered(self, key: Hashable, now: Optional[datetime] = None) -> None:
+        """Call when the action we are tracking was triggered."""
+        self.async_cancel_timer(key)
+        self._last_triggered[key] = now or dt_util.utcnow()
+
+    @callback
+    def async_cancel_timer(self, key: Hashable) -> None:
+        """Cancel a rate limit time that will call the action."""
+        if not self.async_has_timer(key):
+            return
+
+        self._rate_limit_timers.pop(key).cancel()
+
+    @callback
+    def async_remove(self) -> None:
+        """Remove all timers."""
+        for timer in self._rate_limit_timers.values():
+            timer.cancel()
+        self._rate_limit_timers.clear()
+
+    @callback
+    def async_schedule_action(
+        self,
+        key: Hashable,
+        rate_limit: Optional[timedelta],
+        now: datetime,
+        action: Callable,
+        *args: Any,
+    ) -> Optional[datetime]:
+        """Check rate limits and schedule an action if we hit the limit.
+
+        If the rate limit is hit:
+            Schedules the action for when the rate limit expires
+            if there are no pending timers. The action must
+            be called in async.
+
+            Returns the time the rate limit will expire
+
+        If the rate limit is not hit:
+
+            Return None
+        """
+        if rate_limit is None or key not in self._last_triggered:
+            return None
+
+        next_call_time = self._last_triggered[key] + rate_limit
+
+        if next_call_time <= now:
+            self.async_cancel_timer(key)
+            return None
+
+        _LOGGER.debug(
+            "Reached rate limit of %s for %s and deferred action until %s",
+            rate_limit,
+            key,
+            next_call_time,
+        )
+
+        if key not in self._rate_limit_timers:
+            self._rate_limit_timers[key] = self.hass.loop.call_later(
+                (next_call_time - now).total_seconds() + MAX_TIME_TRACKING_ERROR,
+                action,
+                *args,
+            )
+
+        return next_call_time
diff --git a/homeassistant/helpers/template.py b/homeassistant/helpers/template.py
index 6261f7b2257..b877e0b0e12 100644
--- a/homeassistant/helpers/template.py
+++ b/homeassistant/helpers/template.py
@@ -72,6 +72,8 @@ _COLLECTABLE_STATE_ATTRIBUTES = {
     "name",
 }
 
+DEFAULT_RATE_LIMIT = timedelta(seconds=1)
+
 
 @bind_hass
 def attach(hass: HomeAssistantType, obj: Any) -> None:
@@ -198,10 +200,11 @@ class RenderInfo:
         self.domains = set()
         self.domains_lifecycle = set()
         self.entities = set()
+        self.rate_limit = None
 
     def __repr__(self) -> str:
         """Representation of RenderInfo."""
-        return f"<RenderInfo {self.template} all_states={self.all_states} all_states_lifecycle={self.all_states_lifecycle} domains={self.domains} domains_lifecycle={self.domains_lifecycle} entities={self.entities}>"
+        return f"<RenderInfo {self.template} all_states={self.all_states} all_states_lifecycle={self.all_states_lifecycle} domains={self.domains} domains_lifecycle={self.domains_lifecycle} entities={self.entities} rate_limit={self.rate_limit}>"
 
     def _filter_domains_and_entities(self, entity_id: str) -> bool:
         """Template should re-render if the entity state changes when we match specific domains or entities."""
@@ -221,16 +224,24 @@ class RenderInfo:
 
     def _freeze_static(self) -> None:
         self.is_static = True
-        self.entities = frozenset(self.entities)
-        self.domains = frozenset(self.domains)
-        self.domains_lifecycle = frozenset(self.domains_lifecycle)
+        self._freeze_sets()
         self.all_states = False
 
-    def _freeze(self) -> None:
+    def _freeze_sets(self) -> None:
         self.entities = frozenset(self.entities)
         self.domains = frozenset(self.domains)
         self.domains_lifecycle = frozenset(self.domains_lifecycle)
 
+    def _freeze(self) -> None:
+        self._freeze_sets()
+
+        if self.rate_limit is None and (
+            self.domains or self.domains_lifecycle or self.all_states or self.exception
+        ):
+            # If the template accesses all states or an entire
+            # domain, and no rate limit is set, we use the default.
+            self.rate_limit = DEFAULT_RATE_LIMIT
+
         if self.exception:
             return
 
@@ -478,6 +489,26 @@ class Template:
         return 'Template("' + self.template + '")'
 
 
+class RateLimit:
+    """Class to control update rate limits."""
+
+    def __init__(self, hass: HomeAssistantType):
+        """Initialize rate limit."""
+        self._hass = hass
+
+    def __call__(self, *args: Any, **kwargs: Any) -> str:
+        """Handle a call to the class."""
+        render_info = self._hass.data.get(_RENDER_INFO)
+        if render_info is not None:
+            render_info.rate_limit = timedelta(*args, **kwargs)
+
+        return ""
+
+    def __repr__(self) -> str:
+        """Representation of a RateLimit."""
+        return "<template RateLimit>"
+
+
 class AllStates:
     """Class to expose all HA states as attributes."""
 
@@ -1279,10 +1310,11 @@ class TemplateEnvironment(ImmutableSandboxedEnvironment):
         self.globals["is_state_attr"] = hassfunction(is_state_attr)
         self.globals["state_attr"] = hassfunction(state_attr)
         self.globals["states"] = AllStates(hass)
+        self.globals["rate_limit"] = RateLimit(hass)
 
     def is_safe_callable(self, obj):
         """Test if callback is safe."""
-        return isinstance(obj, AllStates) or super().is_safe_callable(obj)
+        return isinstance(obj, (AllStates, RateLimit)) or super().is_safe_callable(obj)
 
     def is_safe_attribute(self, obj, attr, value):
         """Test if attribute is safe."""
diff --git a/tests/components/template/test_cover.py b/tests/components/template/test_cover.py
index 5deb540782c..b068f04b87b 100644
--- a/tests/components/template/test_cover.py
+++ b/tests/components/template/test_cover.py
@@ -115,6 +115,7 @@ async def test_template_state_boolean(hass, calls):
 
 async def test_template_position(hass, calls):
     """Test the position_template attribute."""
+    hass.states.async_set("cover.test", STATE_OPEN)
     with assert_setup_component(1, "cover"):
         assert await setup.async_setup_component(
             hass,
diff --git a/tests/components/template/test_sensor.py b/tests/components/template/test_sensor.py
index 6c9bfa7e632..23d20250f30 100644
--- a/tests/components/template/test_sensor.py
+++ b/tests/components/template/test_sensor.py
@@ -1,5 +1,6 @@
 """The test for the Template sensor platform."""
 from asyncio import Event
+from datetime import timedelta
 from unittest.mock import patch
 
 from homeassistant.bootstrap import async_from_config_dict
@@ -17,7 +18,11 @@ from homeassistant.helpers.template import Template
 from homeassistant.setup import ATTR_COMPONENT, async_setup_component, setup_component
 import homeassistant.util.dt as dt_util
 
-from tests.common import assert_setup_component, get_test_home_assistant
+from tests.common import (
+    assert_setup_component,
+    async_fire_time_changed,
+    get_test_home_assistant,
+)
 
 
 class TestTemplateSensor:
@@ -900,8 +905,13 @@ async def test_self_referencing_entity_picture_loop(hass, caplog):
 
     assert len(hass.states.async_all()) == 1
 
-    await hass.async_block_till_done()
-    await hass.async_block_till_done()
+    next_time = dt_util.utcnow() + timedelta(seconds=1.2)
+    with patch(
+        "homeassistant.helpers.ratelimit.dt_util.utcnow", return_value=next_time
+    ):
+        async_fire_time_changed(hass, next_time)
+        await hass.async_block_till_done()
+        await hass.async_block_till_done()
 
     assert "Template loop detected" in caplog.text
 
diff --git a/tests/helpers/test_event.py b/tests/helpers/test_event.py
index 887917fa74c..32d203ddc6e 100644
--- a/tests/helpers/test_event.py
+++ b/tests/helpers/test_event.py
@@ -927,7 +927,7 @@ async def test_track_template_result_complex(hass):
     """Test tracking template."""
     specific_runs = []
     template_complex_str = """
-
+{{ rate_limit(seconds=0) }}
 {% if states("sensor.domain") == "light" %}
   {{ states.light | map(attribute='entity_id') | list }}
 {% elif states("sensor.domain") == "lock" %}
@@ -1162,6 +1162,8 @@ async def test_track_template_result_with_group(hass):
         await hass.services.async_call("group", "reload")
         await hass.async_block_till_done()
 
+    info.async_refresh()
+    await hass.async_block_till_done()
     assert specific_runs[-1] == str(100.1 + 200.2 + 0 + 800.8)
 
 
@@ -1234,7 +1236,7 @@ async def test_track_template_result_iterator(hass):
         [
             TrackTemplate(
                 Template(
-                    """
+                    """{{ rate_limit(seconds=0) }}
             {% for state in states.sensor %}
                 {% if state.state == 'on' %}
                     {{ state.entity_id }},
@@ -1266,7 +1268,7 @@ async def test_track_template_result_iterator(hass):
         [
             TrackTemplate(
                 Template(
-                    """{{ states.sensor|selectattr("state","equalto","on")
+                    """{{ rate_limit(seconds=0) }}{{ states.sensor|selectattr("state","equalto","on")
                 |join(",", attribute="entity_id") }}""",
                     hass,
                 ),
@@ -1397,6 +1399,335 @@ async def test_static_string(hass):
     assert refresh_runs == ["static"]
 
 
+async def test_track_template_rate_limit(hass):
+    """Test template rate limit."""
+    template_refresh = Template("{{ states | count }}", hass)
+
+    refresh_runs = []
+
+    @ha.callback
+    def refresh_listener(event, updates):
+        refresh_runs.append(updates.pop().result)
+
+    info = async_track_template_result(
+        hass,
+        [TrackTemplate(template_refresh, None, timedelta(seconds=0.1))],
+        refresh_listener,
+    )
+    await hass.async_block_till_done()
+    info.async_refresh()
+    await hass.async_block_till_done()
+
+    assert refresh_runs == ["0"]
+    hass.states.async_set("sensor.one", "any")
+    await hass.async_block_till_done()
+    assert refresh_runs == ["0"]
+    info.async_refresh()
+    assert refresh_runs == ["0", "1"]
+    hass.states.async_set("sensor.two", "any")
+    await hass.async_block_till_done()
+    assert refresh_runs == ["0", "1"]
+    next_time = dt_util.utcnow() + timedelta(seconds=0.125)
+    with patch(
+        "homeassistant.helpers.ratelimit.dt_util.utcnow", return_value=next_time
+    ):
+        async_fire_time_changed(hass, next_time)
+        await hass.async_block_till_done()
+    assert refresh_runs == ["0", "1", "2"]
+    hass.states.async_set("sensor.three", "any")
+    await hass.async_block_till_done()
+    assert refresh_runs == ["0", "1", "2"]
+    hass.states.async_set("sensor.four", "any")
+    await hass.async_block_till_done()
+    assert refresh_runs == ["0", "1", "2"]
+    next_time = dt_util.utcnow() + timedelta(seconds=0.125 * 2)
+    with patch(
+        "homeassistant.helpers.ratelimit.dt_util.utcnow", return_value=next_time
+    ):
+        async_fire_time_changed(hass, next_time)
+        await hass.async_block_till_done()
+    assert refresh_runs == ["0", "1", "2", "4"]
+    hass.states.async_set("sensor.five", "any")
+    await hass.async_block_till_done()
+    assert refresh_runs == ["0", "1", "2", "4"]
+
+
+async def test_track_template_rate_limit_overridden(hass):
+    """Test template rate limit can be overridden from the template."""
+    template_refresh = Template(
+        "{% set x = rate_limit(seconds=0.1) %}{{ states | count }}", hass
+    )
+
+    refresh_runs = []
+
+    @ha.callback
+    def refresh_listener(event, updates):
+        refresh_runs.append(updates.pop().result)
+
+    info = async_track_template_result(
+        hass,
+        [TrackTemplate(template_refresh, None, timedelta(seconds=5))],
+        refresh_listener,
+    )
+    await hass.async_block_till_done()
+    info.async_refresh()
+    await hass.async_block_till_done()
+
+    assert refresh_runs == ["0"]
+    hass.states.async_set("sensor.one", "any")
+    await hass.async_block_till_done()
+    assert refresh_runs == ["0"]
+    info.async_refresh()
+    assert refresh_runs == ["0", "1"]
+    hass.states.async_set("sensor.two", "any")
+    await hass.async_block_till_done()
+    assert refresh_runs == ["0", "1"]
+    next_time = dt_util.utcnow() + timedelta(seconds=0.125)
+    with patch(
+        "homeassistant.helpers.ratelimit.dt_util.utcnow", return_value=next_time
+    ):
+        async_fire_time_changed(hass, next_time)
+        await hass.async_block_till_done()
+    assert refresh_runs == ["0", "1", "2"]
+    hass.states.async_set("sensor.three", "any")
+    await hass.async_block_till_done()
+    assert refresh_runs == ["0", "1", "2"]
+    hass.states.async_set("sensor.four", "any")
+    await hass.async_block_till_done()
+    assert refresh_runs == ["0", "1", "2"]
+    next_time = dt_util.utcnow() + timedelta(seconds=0.125 * 2)
+    with patch(
+        "homeassistant.helpers.ratelimit.dt_util.utcnow", return_value=next_time
+    ):
+        async_fire_time_changed(hass, next_time)
+        await hass.async_block_till_done()
+    await hass.async_block_till_done()
+    assert refresh_runs == ["0", "1", "2", "4"]
+    hass.states.async_set("sensor.five", "any")
+    await hass.async_block_till_done()
+    assert refresh_runs == ["0", "1", "2", "4"]
+
+
+async def test_track_template_rate_limit_five(hass):
+    """Test template rate limit of 5 seconds."""
+    template_refresh = Template("{{ states | count }}", hass)
+
+    refresh_runs = []
+
+    @ha.callback
+    def refresh_listener(event, updates):
+        refresh_runs.append(updates.pop().result)
+
+    info = async_track_template_result(
+        hass,
+        [TrackTemplate(template_refresh, None, timedelta(seconds=5))],
+        refresh_listener,
+    )
+    await hass.async_block_till_done()
+    info.async_refresh()
+    await hass.async_block_till_done()
+
+    assert refresh_runs == ["0"]
+    hass.states.async_set("sensor.one", "any")
+    await hass.async_block_till_done()
+    assert refresh_runs == ["0"]
+    info.async_refresh()
+    assert refresh_runs == ["0", "1"]
+    hass.states.async_set("sensor.two", "any")
+    await hass.async_block_till_done()
+    assert refresh_runs == ["0", "1"]
+    hass.states.async_set("sensor.three", "any")
+    await hass.async_block_till_done()
+    assert refresh_runs == ["0", "1"]
+
+
+async def test_track_template_rate_limit_changes(hass):
+    """Test template rate limit can be changed."""
+    template_refresh = Template(
+        """
+        {% if states.sensor.two.state == "any" %}
+            {% set x = rate_limit(seconds=5) %}
+        {% else %}
+            {% set x = rate_limit(seconds=0.1) %}
+        {% endif %}
+        {{ states | count }}
+        """,
+        hass,
+    )
+
+    refresh_runs = []
+
+    @ha.callback
+    def refresh_listener(event, updates):
+        refresh_runs.append(updates.pop().result)
+
+    info = async_track_template_result(
+        hass,
+        [TrackTemplate(template_refresh, None)],
+        refresh_listener,
+    )
+    await hass.async_block_till_done()
+    info.async_refresh()
+    await hass.async_block_till_done()
+
+    assert refresh_runs == ["0"]
+    hass.states.async_set("sensor.one", "any")
+    await hass.async_block_till_done()
+    assert refresh_runs == ["0"]
+    info.async_refresh()
+    assert refresh_runs == ["0", "1"]
+    hass.states.async_set("sensor.two", "any")
+    await hass.async_block_till_done()
+    assert refresh_runs == ["0", "1"]
+    next_time = dt_util.utcnow() + timedelta(seconds=0.125 * 1)
+    with patch(
+        "homeassistant.helpers.ratelimit.dt_util.utcnow", return_value=next_time
+    ):
+        async_fire_time_changed(hass, next_time)
+        await hass.async_block_till_done()
+    await hass.async_block_till_done()
+    assert refresh_runs == ["0", "1", "2"]
+    hass.states.async_set("sensor.three", "any")
+    await hass.async_block_till_done()
+    assert refresh_runs == ["0", "1", "2"]
+    hass.states.async_set("sensor.four", "any")
+    await hass.async_block_till_done()
+    assert refresh_runs == ["0", "1", "2"]
+    next_time = dt_util.utcnow() + timedelta(seconds=0.125 * 2)
+    with patch(
+        "homeassistant.helpers.ratelimit.dt_util.utcnow", return_value=next_time
+    ):
+        async_fire_time_changed(hass, next_time)
+        await hass.async_block_till_done()
+    await hass.async_block_till_done()
+    assert refresh_runs == ["0", "1", "2"]
+    hass.states.async_set("sensor.five", "any")
+    await hass.async_block_till_done()
+    assert refresh_runs == ["0", "1", "2"]
+
+
+async def test_track_template_rate_limit_removed(hass):
+    """Test template rate limit can be removed."""
+    template_refresh = Template(
+        """
+        {% if states.sensor.two.state == "any" %}
+            {% set x = rate_limit(0) %}
+        {% else %}
+            {% set x = rate_limit(seconds=0.1) %}
+        {% endif %}
+        {{ states | count }}
+        """,
+        hass,
+    )
+
+    refresh_runs = []
+
+    @ha.callback
+    def refresh_listener(event, updates):
+        refresh_runs.append(updates.pop().result)
+
+    info = async_track_template_result(
+        hass,
+        [TrackTemplate(template_refresh, None)],
+        refresh_listener,
+    )
+    await hass.async_block_till_done()
+    info.async_refresh()
+    await hass.async_block_till_done()
+
+    assert refresh_runs == ["0"]
+    hass.states.async_set("sensor.one", "any")
+    await hass.async_block_till_done()
+    assert refresh_runs == ["0"]
+    info.async_refresh()
+    assert refresh_runs == ["0", "1"]
+    hass.states.async_set("sensor.two", "any")
+    await hass.async_block_till_done()
+    assert refresh_runs == ["0", "1"]
+    next_time = dt_util.utcnow() + timedelta(seconds=0.125 * 1)
+    with patch(
+        "homeassistant.helpers.ratelimit.dt_util.utcnow", return_value=next_time
+    ):
+        async_fire_time_changed(hass, next_time)
+        await hass.async_block_till_done()
+    await hass.async_block_till_done()
+    assert refresh_runs == ["0", "1", "2"]
+    hass.states.async_set("sensor.three", "any")
+    await hass.async_block_till_done()
+    assert refresh_runs == ["0", "1", "2", "3"]
+    hass.states.async_set("sensor.four", "any")
+    await hass.async_block_till_done()
+    assert refresh_runs == ["0", "1", "2", "3", "4"]
+    hass.states.async_set("sensor.five", "any")
+    await hass.async_block_till_done()
+    assert refresh_runs == ["0", "1", "2", "3", "4", "5"]
+
+
+async def test_track_two_templates_with_different_rate_limits(hass):
+    """Test two templates with different rate limits."""
+    template_one = Template(
+        "{% set x = rate_limit(seconds=0.1) %}{{ states | count }}", hass
+    )
+    template_five = Template(
+        "{% set x = rate_limit(seconds=5) %}{{ states | count }}", hass
+    )
+
+    refresh_runs = {
+        template_one: [],
+        template_five: [],
+    }
+
+    @ha.callback
+    def refresh_listener(event, updates):
+        for update in updates:
+            refresh_runs[update.template].append(update.result)
+
+    info = async_track_template_result(
+        hass,
+        [TrackTemplate(template_one, None), TrackTemplate(template_five, None)],
+        refresh_listener,
+    )
+
+    await hass.async_block_till_done()
+    info.async_refresh()
+    await hass.async_block_till_done()
+
+    assert refresh_runs[template_one] == ["0"]
+    assert refresh_runs[template_five] == ["0"]
+    hass.states.async_set("sensor.one", "any")
+    await hass.async_block_till_done()
+    assert refresh_runs[template_one] == ["0"]
+    assert refresh_runs[template_five] == ["0"]
+    info.async_refresh()
+    assert refresh_runs[template_one] == ["0", "1"]
+    assert refresh_runs[template_five] == ["0", "1"]
+    hass.states.async_set("sensor.two", "any")
+    await hass.async_block_till_done()
+    assert refresh_runs[template_one] == ["0", "1"]
+    assert refresh_runs[template_five] == ["0", "1"]
+    next_time = dt_util.utcnow() + timedelta(seconds=0.125 * 1)
+    with patch(
+        "homeassistant.helpers.ratelimit.dt_util.utcnow", return_value=next_time
+    ):
+        async_fire_time_changed(hass, next_time)
+        await hass.async_block_till_done()
+    await hass.async_block_till_done()
+    assert refresh_runs[template_one] == ["0", "1", "2"]
+    assert refresh_runs[template_five] == ["0", "1"]
+    hass.states.async_set("sensor.three", "any")
+    await hass.async_block_till_done()
+    assert refresh_runs[template_one] == ["0", "1", "2"]
+    assert refresh_runs[template_five] == ["0", "1"]
+    hass.states.async_set("sensor.four", "any")
+    await hass.async_block_till_done()
+    assert refresh_runs[template_one] == ["0", "1", "2"]
+    assert refresh_runs[template_five] == ["0", "1"]
+    hass.states.async_set("sensor.five", "any")
+    await hass.async_block_till_done()
+    assert refresh_runs[template_one] == ["0", "1", "2"]
+    assert refresh_runs[template_five] == ["0", "1"]
+
+
 async def test_string(hass):
     """Test a string."""
     template_refresh = Template("no_template", hass)
@@ -1536,7 +1867,9 @@ async def test_async_track_template_result_multiple_templates_mixing_domain(hass
     template_1 = Template("{{ states.switch.test.state == 'on' }}")
     template_2 = Template("{{ states.switch.test.state == 'on' }}")
     template_3 = Template("{{ states.switch.test.state == 'off' }}")
-    template_4 = Template("{{ states.switch | map(attribute='entity_id') | list }}")
+    template_4 = Template(
+        "{{ rate_limit(seconds=0) }}{{ states.switch | map(attribute='entity_id') | list }}"
+    )
 
     refresh_runs = []
 
diff --git a/tests/helpers/test_ratelimit.py b/tests/helpers/test_ratelimit.py
new file mode 100644
index 00000000000..c34de9586dd
--- /dev/null
+++ b/tests/helpers/test_ratelimit.py
@@ -0,0 +1,108 @@
+"""Tests for ratelimit."""
+import asyncio
+from datetime import timedelta
+
+from homeassistant.core import callback
+from homeassistant.helpers import ratelimit
+from homeassistant.util import dt as dt_util
+
+
+async def test_hit(hass):
+    """Test hitting the rate limit."""
+
+    refresh_called = False
+
+    @callback
+    def _refresh():
+        nonlocal refresh_called
+        refresh_called = True
+        return
+
+    rate_limiter = ratelimit.KeyedRateLimit(hass)
+    rate_limiter.async_triggered("key1", dt_util.utcnow())
+
+    assert (
+        rate_limiter.async_schedule_action(
+            "key1", timedelta(seconds=0.001), dt_util.utcnow(), _refresh
+        )
+        is not None
+    )
+
+    assert not refresh_called
+
+    assert rate_limiter.async_has_timer("key1")
+
+    await asyncio.sleep(0.002)
+    assert refresh_called
+
+    assert (
+        rate_limiter.async_schedule_action(
+            "key2", timedelta(seconds=0.001), dt_util.utcnow(), _refresh
+        )
+        is None
+    )
+    rate_limiter.async_remove()
+
+
+async def test_miss(hass):
+    """Test missing the rate limit."""
+
+    refresh_called = False
+
+    @callback
+    def _refresh():
+        nonlocal refresh_called
+        refresh_called = True
+        return
+
+    rate_limiter = ratelimit.KeyedRateLimit(hass)
+    assert (
+        rate_limiter.async_schedule_action(
+            "key1", timedelta(seconds=0.1), dt_util.utcnow(), _refresh
+        )
+        is None
+    )
+    assert not refresh_called
+    assert not rate_limiter.async_has_timer("key1")
+
+    assert (
+        rate_limiter.async_schedule_action(
+            "key1", timedelta(seconds=0.1), dt_util.utcnow(), _refresh
+        )
+        is None
+    )
+    assert not refresh_called
+    assert not rate_limiter.async_has_timer("key1")
+    rate_limiter.async_remove()
+
+
+async def test_no_limit(hass):
+    """Test async_schedule_action always return None when there is no rate limit."""
+
+    refresh_called = False
+
+    @callback
+    def _refresh():
+        nonlocal refresh_called
+        refresh_called = True
+        return
+
+    rate_limiter = ratelimit.KeyedRateLimit(hass)
+    rate_limiter.async_triggered("key1", dt_util.utcnow())
+
+    assert (
+        rate_limiter.async_schedule_action("key1", None, dt_util.utcnow(), _refresh)
+        is None
+    )
+    assert not refresh_called
+    assert not rate_limiter.async_has_timer("key1")
+
+    rate_limiter.async_triggered("key1", dt_util.utcnow())
+
+    assert (
+        rate_limiter.async_schedule_action("key1", None, dt_util.utcnow(), _refresh)
+        is None
+    )
+    assert not refresh_called
+    assert not rate_limiter.async_has_timer("key1")
+    rate_limiter.async_remove()
diff --git a/tests/helpers/test_template.py b/tests/helpers/test_template.py
index 20401f6fbdf..0a5735a98ff 100644
--- a/tests/helpers/test_template.py
+++ b/tests/helpers/test_template.py
@@ -1,5 +1,5 @@
 """Test Home Assistant template helper methods."""
-from datetime import datetime
+from datetime import datetime, timedelta
 import math
 import random
 
@@ -149,6 +149,7 @@ def test_iterating_all_states(hass):
 
     info = render_to_info(hass, tmpl_str)
     assert_result_info(info, "", all_states=True)
+    assert info.rate_limit == template.DEFAULT_RATE_LIMIT
 
     hass.states.async_set("test.object", "happy")
     hass.states.async_set("sensor.temperature", 10)
@@ -165,6 +166,7 @@ def test_iterating_domain_states(hass):
 
     info = render_to_info(hass, tmpl_str)
     assert_result_info(info, "", domains=["sensor"])
+    assert info.rate_limit == template.DEFAULT_RATE_LIMIT
 
     hass.states.async_set("test.object", "happy")
     hass.states.async_set("sensor.back_door", "open")
@@ -1342,6 +1344,7 @@ async def test_closest_function_home_vs_group_entity_id(hass):
     assert_result_info(
         info, "test_domain.object", {"group.location_group", "test_domain.object"}
     )
+    assert info.rate_limit is None
 
 
 async def test_closest_function_home_vs_group_state(hass):
@@ -1369,20 +1372,24 @@ async def test_closest_function_home_vs_group_state(hass):
     assert_result_info(
         info, "test_domain.object", {"group.location_group", "test_domain.object"}
     )
+    assert info.rate_limit is None
 
     info = render_to_info(hass, "{{ closest(states.group.location_group).entity_id }}")
     assert_result_info(
         info, "test_domain.object", {"test_domain.object", "group.location_group"}
     )
+    assert info.rate_limit is None
 
 
 async def test_expand(hass):
     """Test expand function."""
     info = render_to_info(hass, "{{ expand('test.object') }}")
     assert_result_info(info, "[]", ["test.object"])
+    assert info.rate_limit is None
 
     info = render_to_info(hass, "{{ expand(56) }}")
     assert_result_info(info, "[]")
+    assert info.rate_limit is None
 
     hass.states.async_set("test.object", "happy")
 
@@ -1390,17 +1397,20 @@ async def test_expand(hass):
         hass, "{{ expand('test.object') | map(attribute='entity_id') | join(', ') }}"
     )
     assert_result_info(info, "test.object", ["test.object"])
+    assert info.rate_limit is None
 
     info = render_to_info(
         hass,
         "{{ expand('group.new_group') | map(attribute='entity_id') | join(', ') }}",
     )
     assert_result_info(info, "", ["group.new_group"])
+    assert info.rate_limit is None
 
     info = render_to_info(
         hass, "{{ expand(states.group) | map(attribute='entity_id') | join(', ') }}"
     )
     assert_result_info(info, "", [], ["group"])
+    assert info.rate_limit == template.DEFAULT_RATE_LIMIT
 
     assert await async_setup_component(hass, "group", {})
     await hass.async_block_till_done()
@@ -1411,6 +1421,7 @@ async def test_expand(hass):
         "{{ expand('group.new_group') | map(attribute='entity_id') | join(', ') }}",
     )
     assert_result_info(info, "test.object", {"group.new_group", "test.object"})
+    assert info.rate_limit is None
 
     info = render_to_info(
         hass, "{{ expand(states.group) | map(attribute='entity_id') | join(', ') }}"
@@ -1418,6 +1429,7 @@ async def test_expand(hass):
     assert_result_info(
         info, "test.object", {"test.object", "group.new_group"}, ["group"]
     )
+    assert info.rate_limit == template.DEFAULT_RATE_LIMIT
 
     info = render_to_info(
         hass,
@@ -1432,6 +1444,7 @@ async def test_expand(hass):
         " | map(attribute='entity_id') | join(', ') }}",
     )
     assert_result_info(info, "test.object", {"test.object", "group.new_group"})
+    assert info.rate_limit is None
 
     hass.states.async_set("sensor.power_1", 0)
     hass.states.async_set("sensor.power_2", 200.2)
@@ -1452,6 +1465,7 @@ async def test_expand(hass):
         str(200.2 + 400.4),
         {"group.power_sensors", "sensor.power_1", "sensor.power_2", "sensor.power_3"},
     )
+    assert info.rate_limit is None
 
 
 def test_closest_function_to_coord(hass):
@@ -1517,6 +1531,7 @@ def test_async_render_to_info_with_branching(hass):
 """,
     )
     assert_result_info(info, "off", {"light.a", "light.c"})
+    assert info.rate_limit is None
 
     info = render_to_info(
         hass,
@@ -1528,6 +1543,7 @@ def test_async_render_to_info_with_branching(hass):
 """,
     )
     assert_result_info(info, "on", {"light.a", "light.b"})
+    assert info.rate_limit is None
 
 
 def test_async_render_to_info_with_complex_branching(hass):
@@ -1564,6 +1580,7 @@ def test_async_render_to_info_with_complex_branching(hass):
     )
 
     assert_result_info(info, "['sensor.a']", {"light.a", "light.b"}, {"sensor"})
+    assert info.rate_limit == template.DEFAULT_RATE_LIMIT
 
 
 async def test_async_render_to_info_with_wildcard_matching_entity_id(hass):
@@ -1589,6 +1606,7 @@ async def test_async_render_to_info_with_wildcard_matching_entity_id(hass):
         "cover.office_skylight",
     }
     assert info.all_states is True
+    assert info.rate_limit == template.DEFAULT_RATE_LIMIT
 
 
 async def test_async_render_to_info_with_wildcard_matching_state(hass):
@@ -1619,6 +1637,7 @@ async def test_async_render_to_info_with_wildcard_matching_state(hass):
         "cover.office_skylight",
     }
     assert info.all_states is True
+    assert info.rate_limit == template.DEFAULT_RATE_LIMIT
 
     hass.states.async_set("binary_sensor.door", "closed")
     info = render_to_info(hass, template_complex_str)
@@ -1632,6 +1651,7 @@ async def test_async_render_to_info_with_wildcard_matching_state(hass):
         "cover.office_skylight",
     }
     assert info.all_states is True
+    assert info.rate_limit == template.DEFAULT_RATE_LIMIT
 
     template_cover_str = """
 
@@ -1653,6 +1673,7 @@ async def test_async_render_to_info_with_wildcard_matching_state(hass):
         "cover.office_skylight",
     }
     assert info.all_states is False
+    assert info.rate_limit == template.DEFAULT_RATE_LIMIT
 
 
 def test_nested_async_render_to_info_case(hass):
@@ -1665,6 +1686,7 @@ def test_nested_async_render_to_info_case(hass):
         hass, "{{ states[states['input_select.picker'].state].state }}", {}
     )
     assert_result_info(info, "off", {"input_select.picker", "vacuum.a"})
+    assert info.rate_limit is None
 
 
 def test_result_as_boolean(hass):
@@ -2459,6 +2481,7 @@ async def test_lifecycle(hass):
     info = tmp.async_render_to_info()
     assert info.all_states is False
     assert info.all_states_lifecycle is True
+    assert info.rate_limit is None
     assert info.entities == set()
     assert info.domains == set()
     assert info.domains_lifecycle == set()
@@ -2594,3 +2617,28 @@ async def test_unavailable_states(hass):
         hass,
     )
     assert tpl.async_render() == "light.none, light.unavailable, light.unknown"
+
+
+async def test_rate_limit(hass):
+    """Test we can pickup a rate limit directive."""
+    tmp = template.Template("{{ states | count }}", hass)
+
+    info = tmp.async_render_to_info()
+    assert info.rate_limit is None
+
+    tmp = template.Template("{{ rate_limit(minutes=1) }}{{ states | count }}", hass)
+
+    info = tmp.async_render_to_info()
+    assert info.rate_limit == timedelta(minutes=1)
+
+    tmp = template.Template("{{ rate_limit(minutes=1) }}random", hass)
+
+    info = tmp.async_render_to_info()
+    assert info.result() == "random"
+    assert info.rate_limit == timedelta(minutes=1)
+
+    tmp = template.Template("{{ rate_limit(seconds=0) }}random", hass)
+
+    info = tmp.async_render_to_info()
+    assert info.result() == "random"
+    assert info.rate_limit == timedelta(seconds=0)

From c0d4e1eaf416251f228be020780dad66432ffb2a Mon Sep 17 00:00:00 2001
From: jjlawren <jjlawren@users.noreply.github.com>
Date: Thu, 1 Oct 2020 02:57:45 -0500
Subject: [PATCH 04/82] Accept new Plex websocket callback payloads (#40773)

---
 homeassistant/components/plex/__init__.py   | 52 +++++++++++++++++----
 homeassistant/components/plex/manifest.json |  2 +-
 requirements_all.txt                        |  2 +-
 requirements_test_all.txt                   |  2 +-
 tests/components/plex/helpers.py            |  3 +-
 5 files changed, 47 insertions(+), 14 deletions(-)

diff --git a/homeassistant/components/plex/__init__.py b/homeassistant/components/plex/__init__.py
index fff6dea3bb4..95fb6e4f09f 100644
--- a/homeassistant/components/plex/__init__.py
+++ b/homeassistant/components/plex/__init__.py
@@ -5,7 +5,14 @@ import json
 import logging
 
 import plexapi.exceptions
-from plexwebsocket import PlexWebsocket
+from plexwebsocket import (
+    SIGNAL_CONNECTION_STATE,
+    SIGNAL_DATA,
+    STATE_CONNECTED,
+    STATE_DISCONNECTED,
+    STATE_STOPPED,
+    PlexWebsocket,
+)
 import requests.exceptions
 import voluptuous as vol
 
@@ -14,7 +21,7 @@ from homeassistant.components.media_player.const import (
     ATTR_MEDIA_CONTENT_ID,
     ATTR_MEDIA_CONTENT_TYPE,
 )
-from homeassistant.config_entries import SOURCE_REAUTH
+from homeassistant.config_entries import ENTRY_STATE_SETUP_RETRY, SOURCE_REAUTH
 from homeassistant.const import (
     ATTR_ENTITY_ID,
     CONF_SOURCE,
@@ -95,11 +102,12 @@ async def async_setup_entry(hass, entry):
             entry, data={**entry.data, PLEX_SERVER_CONFIG: new_server_data}
         )
     except requests.exceptions.ConnectionError as error:
-        _LOGGER.error(
-            "Plex server (%s) could not be reached: [%s]",
-            server_config[CONF_URL],
-            error,
-        )
+        if entry.state != ENTRY_STATE_SETUP_RETRY:
+            _LOGGER.error(
+                "Plex server (%s) could not be reached: [%s]",
+                server_config[CONF_URL],
+                error,
+            )
         raise ConfigEntryNotReady from error
     except plexapi.exceptions.Unauthorized:
         hass.async_create_task(
@@ -142,13 +150,37 @@ async def async_setup_entry(hass, entry):
     hass.data[PLEX_DOMAIN][DISPATCHERS].setdefault(server_id, [])
     hass.data[PLEX_DOMAIN][DISPATCHERS][server_id].append(unsub)
 
-    def update_plex():
-        async_dispatcher_send(hass, PLEX_UPDATE_PLATFORMS_SIGNAL.format(server_id))
+    def plex_websocket_callback(signal, data, error):
+        """Handle callbacks from plexwebsocket library."""
+        if signal == SIGNAL_CONNECTION_STATE:
+
+            if data == STATE_CONNECTED:
+                _LOGGER.debug("Websocket to %s successful", entry.data[CONF_SERVER])
+            elif data == STATE_DISCONNECTED:
+                _LOGGER.debug(
+                    "Websocket to %s disconnected, retrying", entry.data[CONF_SERVER]
+                )
+            # Stopped websockets without errors are expected during shutdown and ignored
+            elif data == STATE_STOPPED and error:
+                _LOGGER.error(
+                    "Websocket to %s failed, aborting [Error: %s]",
+                    entry.data[CONF_SERVER],
+                    error,
+                )
+                asyncio.run_coroutine_threadsafe(
+                    hass.config_entries.async_reload(entry.entry_id), hass.loop
+                )
+
+        elif signal == SIGNAL_DATA:
+            async_dispatcher_send(hass, PLEX_UPDATE_PLATFORMS_SIGNAL.format(server_id))
 
     session = async_get_clientsession(hass)
     verify_ssl = server_config.get(CONF_VERIFY_SSL)
     websocket = PlexWebsocket(
-        plex_server.plex_server, update_plex, session=session, verify_ssl=verify_ssl
+        plex_server.plex_server,
+        plex_websocket_callback,
+        session=session,
+        verify_ssl=verify_ssl,
     )
     hass.data[PLEX_DOMAIN][WEBSOCKETS][server_id] = websocket
 
diff --git a/homeassistant/components/plex/manifest.json b/homeassistant/components/plex/manifest.json
index 29b0fe8038e..f5bbc6ac53c 100644
--- a/homeassistant/components/plex/manifest.json
+++ b/homeassistant/components/plex/manifest.json
@@ -6,7 +6,7 @@
   "requirements": [
       "plexapi==4.1.1",
       "plexauth==0.0.5",
-      "plexwebsocket==0.0.11"
+      "plexwebsocket==0.0.12"
   ],
   "dependencies": ["http"],
   "after_dependencies": ["sonos"],
diff --git a/requirements_all.txt b/requirements_all.txt
index 6b1087502c2..c47f8f0759b 100644
--- a/requirements_all.txt
+++ b/requirements_all.txt
@@ -1116,7 +1116,7 @@ plexapi==4.1.1
 plexauth==0.0.5
 
 # homeassistant.components.plex
-plexwebsocket==0.0.11
+plexwebsocket==0.0.12
 
 # homeassistant.components.plum_lightpad
 plumlightpad==0.0.11
diff --git a/requirements_test_all.txt b/requirements_test_all.txt
index 751fb61f179..49b3b9ea1f7 100644
--- a/requirements_test_all.txt
+++ b/requirements_test_all.txt
@@ -533,7 +533,7 @@ plexapi==4.1.1
 plexauth==0.0.5
 
 # homeassistant.components.plex
-plexwebsocket==0.0.11
+plexwebsocket==0.0.12
 
 # homeassistant.components.plum_lightpad
 plumlightpad==0.0.11
diff --git a/tests/components/plex/helpers.py b/tests/components/plex/helpers.py
index 8055ab0d5b1..a20d70fbb7e 100644
--- a/tests/components/plex/helpers.py
+++ b/tests/components/plex/helpers.py
@@ -1,7 +1,8 @@
 """Helper methods for Plex tests."""
+from plexwebsocket import SIGNAL_DATA
 
 
 def trigger_plex_update(mock_websocket):
     """Call the websocket callback method."""
     callback = mock_websocket.call_args[0][1]
-    callback()
+    callback(SIGNAL_DATA, None, None)

From 8bfddbc4b272146f3f3627f8b05cabee18c7242a Mon Sep 17 00:00:00 2001
From: cgtobi <cgtobi@users.noreply.github.com>
Date: Thu, 1 Oct 2020 09:56:46 +0200
Subject: [PATCH 05/82] Fix Netatmo climate error when no boiler status is set
 (#40815)

---
 homeassistant/components/netatmo/climate.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/homeassistant/components/netatmo/climate.py b/homeassistant/components/netatmo/climate.py
index f24591fe954..30ce38753c6 100644
--- a/homeassistant/components/netatmo/climate.py
+++ b/homeassistant/components/netatmo/climate.py
@@ -315,7 +315,7 @@ class NetatmoThermostat(NetatmoBase, ClimateEntity):
     @property
     def hvac_action(self) -> Optional[str]:
         """Return the current running hvac operation if supported."""
-        if self._model == NA_THERM:
+        if self._model == NA_THERM and self._boilerstatus is not None:
             return CURRENT_HVAC_MAP_NETATMO[self._boilerstatus]
         # Maybe it is a valve
         if self._room_status and self._room_status.get("heating_power_request", 0) > 0:

From 9312fd141ed39ce3d3794d2c31a375c8c1b2572f Mon Sep 17 00:00:00 2001
From: Aaron Bach <bachya1208@gmail.com>
Date: Wed, 30 Sep 2020 19:20:10 -0600
Subject: [PATCH 06/82] Bump simplisafe-python to 9.4.1 (#40819)

* Bump simplisafe-python to 9.4.0

* One more bump
---
 homeassistant/components/simplisafe/manifest.json | 2 +-
 requirements_all.txt                              | 2 +-
 requirements_test_all.txt                         | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/homeassistant/components/simplisafe/manifest.json b/homeassistant/components/simplisafe/manifest.json
index f78762b17c8..613187ef744 100644
--- a/homeassistant/components/simplisafe/manifest.json
+++ b/homeassistant/components/simplisafe/manifest.json
@@ -3,6 +3,6 @@
   "name": "SimpliSafe",
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/simplisafe",
-  "requirements": ["simplisafe-python==9.3.3"],
+  "requirements": ["simplisafe-python==9.4.1"],
   "codeowners": ["@bachya"]
 }
diff --git a/requirements_all.txt b/requirements_all.txt
index c47f8f0759b..2e178815528 100644
--- a/requirements_all.txt
+++ b/requirements_all.txt
@@ -2000,7 +2000,7 @@ simplehound==0.3
 simplepush==1.1.4
 
 # homeassistant.components.simplisafe
-simplisafe-python==9.3.3
+simplisafe-python==9.4.1
 
 # homeassistant.components.sisyphus
 sisyphus-control==2.2.1
diff --git a/requirements_test_all.txt b/requirements_test_all.txt
index 49b3b9ea1f7..20eb02361f0 100644
--- a/requirements_test_all.txt
+++ b/requirements_test_all.txt
@@ -936,7 +936,7 @@ sharkiqpy==0.1.8
 simplehound==0.3
 
 # homeassistant.components.simplisafe
-simplisafe-python==9.3.3
+simplisafe-python==9.4.1
 
 # homeassistant.components.sleepiq
 sleepyq==0.7

From 10bb39944948dd44622ec974d22a649f46f31380 Mon Sep 17 00:00:00 2001
From: Alexei Chetroi <lexoid@gmail.com>
Date: Wed, 30 Sep 2020 20:53:00 -0400
Subject: [PATCH 07/82] Bump up zha dependencies (#40914)

---
 homeassistant/components/zha/manifest.json | 2 +-
 requirements_all.txt                       | 2 +-
 requirements_test_all.txt                  | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/homeassistant/components/zha/manifest.json b/homeassistant/components/zha/manifest.json
index aa8a797d125..e76aaf7e0df 100644
--- a/homeassistant/components/zha/manifest.json
+++ b/homeassistant/components/zha/manifest.json
@@ -9,7 +9,7 @@
     "zha-quirks==0.0.45",
     "zigpy-cc==0.5.2",
     "zigpy-deconz==0.10.0",
-    "zigpy==0.24.3",
+    "zigpy==0.25.0",
     "zigpy-xbee==0.13.0",
     "zigpy-zigate==0.6.2",
     "zigpy-znp==0.2.0"
diff --git a/requirements_all.txt b/requirements_all.txt
index 2e178815528..a4bab6614c8 100644
--- a/requirements_all.txt
+++ b/requirements_all.txt
@@ -2332,7 +2332,7 @@ zigpy-zigate==0.6.2
 zigpy-znp==0.2.0
 
 # homeassistant.components.zha
-zigpy==0.24.3
+zigpy==0.25.0
 
 # homeassistant.components.zoneminder
 zm-py==0.4.0
diff --git a/requirements_test_all.txt b/requirements_test_all.txt
index 20eb02361f0..305b141f498 100644
--- a/requirements_test_all.txt
+++ b/requirements_test_all.txt
@@ -1089,7 +1089,7 @@ zigpy-zigate==0.6.2
 zigpy-znp==0.2.0
 
 # homeassistant.components.zha
-zigpy==0.24.3
+zigpy==0.25.0
 
 # homeassistant.components.zoneminder
 zm-py==0.4.0

From 6e29eb3165f941d50b54ee7500c9d458946b7202 Mon Sep 17 00:00:00 2001
From: Bram Kragten <mail@bramkragten.nl>
Date: Thu, 1 Oct 2020 11:05:00 +0200
Subject: [PATCH 08/82] Revert using own cast app for media (#40937)

---
 homeassistant/components/cast/media_player.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/homeassistant/components/cast/media_player.py b/homeassistant/components/cast/media_player.py
index f62a73860f3..788da18e8bd 100644
--- a/homeassistant/components/cast/media_player.py
+++ b/homeassistant/components/cast/media_player.py
@@ -39,7 +39,6 @@ from homeassistant.components.media_player.const import (
     SUPPORT_VOLUME_SET,
 )
 from homeassistant.const import (
-    CAST_APP_ID_HOMEASSISTANT,
     CONF_HOST,
     EVENT_HOMEASSISTANT_STOP,
     STATE_IDLE,
@@ -292,7 +291,6 @@ class CastDevice(MediaPlayerEntity):
             ),
             ChromeCastZeroconf.get_zeroconf(),
         )
-        chromecast.media_controller.app_id = CAST_APP_ID_HOMEASSISTANT
         self._chromecast = chromecast
 
         if CAST_MULTIZONE_MANAGER_KEY not in self.hass.data:

From fd91d21b286d3a1244c4948726278b771d137744 Mon Sep 17 00:00:00 2001
From: Bram Kragten <mail@bramkragten.nl>
Date: Thu, 1 Oct 2020 21:56:44 +0200
Subject: [PATCH 09/82] Update frontend to 20201001.0 (#40974)

---
 homeassistant/components/frontend/manifest.json | 2 +-
 homeassistant/package_constraints.txt           | 2 +-
 requirements_all.txt                            | 2 +-
 requirements_test_all.txt                       | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/homeassistant/components/frontend/manifest.json b/homeassistant/components/frontend/manifest.json
index 7fba0a8c689..f6a2e4db0d8 100644
--- a/homeassistant/components/frontend/manifest.json
+++ b/homeassistant/components/frontend/manifest.json
@@ -2,7 +2,7 @@
   "domain": "frontend",
   "name": "Home Assistant Frontend",
   "documentation": "https://www.home-assistant.io/integrations/frontend",
-  "requirements": ["home-assistant-frontend==20200930.0"],
+  "requirements": ["home-assistant-frontend==20201001.0"],
   "dependencies": [
     "api",
     "auth",
diff --git a/homeassistant/package_constraints.txt b/homeassistant/package_constraints.txt
index 35807b5d27f..6d3a9101c75 100644
--- a/homeassistant/package_constraints.txt
+++ b/homeassistant/package_constraints.txt
@@ -13,7 +13,7 @@ defusedxml==0.6.0
 distro==1.5.0
 emoji==0.5.4
 hass-nabucasa==0.37.0
-home-assistant-frontend==20200930.0
+home-assistant-frontend==20201001.0
 importlib-metadata==1.6.0;python_version<'3.8'
 jinja2>=2.11.2
 netdisco==2.8.2
diff --git a/requirements_all.txt b/requirements_all.txt
index a4bab6614c8..b973deb1de2 100644
--- a/requirements_all.txt
+++ b/requirements_all.txt
@@ -753,7 +753,7 @@ hole==0.5.1
 holidays==0.10.3
 
 # homeassistant.components.frontend
-home-assistant-frontend==20200930.0
+home-assistant-frontend==20201001.0
 
 # homeassistant.components.zwave
 homeassistant-pyozw==0.1.10
diff --git a/requirements_test_all.txt b/requirements_test_all.txt
index 305b141f498..c8ceb1aa5e2 100644
--- a/requirements_test_all.txt
+++ b/requirements_test_all.txt
@@ -376,7 +376,7 @@ hole==0.5.1
 holidays==0.10.3
 
 # homeassistant.components.frontend
-home-assistant-frontend==20200930.0
+home-assistant-frontend==20201001.0
 
 # homeassistant.components.zwave
 homeassistant-pyozw==0.1.10

From 953a1ddc8c04b08453d514e334d74bf7ef47957f Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Thu, 1 Oct 2020 12:57:52 -0500
Subject: [PATCH 10/82] Prevent sqlalchemy from refetching the old_state_id as
 it will never change (#40982)

Disable expire_on_commit for the event writer. Since we never expect the
old_state_id to change in the database, it was never worth the expense of
refetching the id after the commit.
---
 homeassistant/components/recorder/__init__.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/homeassistant/components/recorder/__init__.py b/homeassistant/components/recorder/__init__.py
index 3bf95b4303a..02a07bab628 100644
--- a/homeassistant/components/recorder/__init__.py
+++ b/homeassistant/components/recorder/__init__.py
@@ -573,7 +573,9 @@ class Recorder(threading.Thread):
         sqlalchemy_event.listen(self.engine, "connect", setup_recorder_connection)
 
         Base.metadata.create_all(self.engine)
-        self.get_session = scoped_session(sessionmaker(bind=self.engine))
+        self.get_session = scoped_session(
+            sessionmaker(bind=self.engine, expire_on_commit=False)
+        )
 
     def _close_connection(self):
         """Close the connection."""

From 0be678c21cdbf72b816505ca378b1dd09274b2d6 Mon Sep 17 00:00:00 2001
From: jjlawren <jjlawren@users.noreply.github.com>
Date: Thu, 1 Oct 2020 14:56:15 -0500
Subject: [PATCH 11/82] Plex websocket callback async cleanup (#40992)

---
 homeassistant/components/plex/__init__.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/homeassistant/components/plex/__init__.py b/homeassistant/components/plex/__init__.py
index 95fb6e4f09f..648e7b7706a 100644
--- a/homeassistant/components/plex/__init__.py
+++ b/homeassistant/components/plex/__init__.py
@@ -29,6 +29,7 @@ from homeassistant.const import (
     CONF_VERIFY_SSL,
     EVENT_HOMEASSISTANT_STOP,
 )
+from homeassistant.core import callback
 from homeassistant.exceptions import ConfigEntryNotReady, HomeAssistantError
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
@@ -150,6 +151,7 @@ async def async_setup_entry(hass, entry):
     hass.data[PLEX_DOMAIN][DISPATCHERS].setdefault(server_id, [])
     hass.data[PLEX_DOMAIN][DISPATCHERS][server_id].append(unsub)
 
+    @callback
     def plex_websocket_callback(signal, data, error):
         """Handle callbacks from plexwebsocket library."""
         if signal == SIGNAL_CONNECTION_STATE:
@@ -167,9 +169,7 @@ async def async_setup_entry(hass, entry):
                     entry.data[CONF_SERVER],
                     error,
                 )
-                asyncio.run_coroutine_threadsafe(
-                    hass.config_entries.async_reload(entry.entry_id), hass.loop
-                )
+                hass.async_create_task(hass.config_entries.async_reload(entry.entry_id))
 
         elif signal == SIGNAL_DATA:
             async_dispatcher_send(hass, PLEX_UPDATE_PLATFORMS_SIGNAL.format(server_id))

From 5f088c7ff0fb57c7a5d6ee45f3fe1403e9bd7386 Mon Sep 17 00:00:00 2001
From: Paulus Schoutsen <balloob@gmail.com>
Date: Thu, 1 Oct 2020 19:58:32 +0000
Subject: [PATCH 12/82] Bumped version to 0.116.0b1

---
 homeassistant/const.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/homeassistant/const.py b/homeassistant/const.py
index 98186047459..1bf14f332fd 100644
--- a/homeassistant/const.py
+++ b/homeassistant/const.py
@@ -1,7 +1,7 @@
 """Constants used by Home Assistant components."""
 MAJOR_VERSION = 0
 MINOR_VERSION = 116
-PATCH_VERSION = "0b0"
+PATCH_VERSION = "0b1"
 __short_version__ = f"{MAJOR_VERSION}.{MINOR_VERSION}"
 __version__ = f"{__short_version__}.{PATCH_VERSION}"
 REQUIRED_PYTHON_VER = (3, 7, 1)

From f89ba744101f3ccc3b61fb067326ab6ef6949e38 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Thu, 1 Oct 2020 15:11:11 -0500
Subject: [PATCH 13/82] Prevent template loop detection from triggering when
 all templates are self referencing (#41013)

---
 .../components/template/template_entity.py    |  4 +-
 tests/components/template/test_cover.py       | 45 +++++++++++++++++++
 tests/components/template/test_sensor.py      | 14 +++---
 3 files changed, 53 insertions(+), 10 deletions(-)

diff --git a/homeassistant/components/template/template_entity.py b/homeassistant/components/template/template_entity.py
index 53d9d2f1a33..49b0edfab02 100644
--- a/homeassistant/components/template/template_entity.py
+++ b/homeassistant/components/template/template_entity.py
@@ -234,9 +234,7 @@ class TemplateEntity(Entity):
         else:
             self._self_ref_update_count = 0
 
-        # If we need to make this less sensitive in the future,
-        # change the '>=' to a '>' here.
-        if self._self_ref_update_count >= len(self._template_attrs):
+        if self._self_ref_update_count > len(self._template_attrs):
             for update in updates:
                 _LOGGER.warning(
                     "Template loop detected while processing event: %s, skipping template render for Template[%s]",
diff --git a/tests/components/template/test_cover.py b/tests/components/template/test_cover.py
index b068f04b87b..7202d8a3a1b 100644
--- a/tests/components/template/test_cover.py
+++ b/tests/components/template/test_cover.py
@@ -1121,3 +1121,48 @@ async def test_state_gets_lowercased(hass):
     hass.states.async_set("binary_sensor.garage_door_sensor", "on")
     await hass.async_block_till_done()
     assert hass.states.get("cover.garage_door").state == STATE_CLOSED
+
+
+async def test_self_referencing_icon_with_no_template_is_not_a_loop(hass, caplog):
+    """Test a self referencing icon with no value template is not a loop."""
+
+    icon_template_str = """{% if is_state('cover.office', 'open') %}
+            mdi:window-shutter-open
+          {% else %}
+            mdi:window-shutter
+          {% endif %}"""
+
+    await setup.async_setup_component(
+        hass,
+        "cover",
+        {
+            "cover": {
+                "platform": "template",
+                "covers": {
+                    "office": {
+                        "icon_template": icon_template_str,
+                        "open_cover": {
+                            "service": "switch.turn_on",
+                            "entity_id": "switch.office_blinds_up",
+                        },
+                        "close_cover": {
+                            "service": "switch.turn_on",
+                            "entity_id": "switch.office_blinds_down",
+                        },
+                        "stop_cover": {
+                            "service": "switch.turn_on",
+                            "entity_id": "switch.office_blinds_up",
+                        },
+                    },
+                },
+            }
+        },
+    )
+
+    await hass.async_block_till_done()
+    await hass.async_start()
+    await hass.async_block_till_done()
+
+    assert len(hass.states.async_all()) == 1
+
+    assert "Template loop detected" not in caplog.text
diff --git a/tests/components/template/test_sensor.py b/tests/components/template/test_sensor.py
index 23d20250f30..8f582f01ef5 100644
--- a/tests/components/template/test_sensor.py
+++ b/tests/components/template/test_sensor.py
@@ -797,9 +797,9 @@ async def test_self_referencing_sensor_loop(hass, caplog):
     assert "Template loop detected" in caplog.text
 
     state = hass.states.get("sensor.test")
-    assert int(state.state) == 1
+    assert int(state.state) == 2
     await hass.async_block_till_done()
-    assert int(state.state) == 1
+    assert int(state.state) == 2
 
 
 async def test_self_referencing_sensor_with_icon_loop(hass, caplog):
@@ -833,11 +833,11 @@ async def test_self_referencing_sensor_with_icon_loop(hass, caplog):
     assert "Template loop detected" in caplog.text
 
     state = hass.states.get("sensor.test")
-    assert int(state.state) == 2
+    assert int(state.state) == 3
     assert state.attributes[ATTR_ICON] == "mdi:greater"
 
     await hass.async_block_till_done()
-    assert int(state.state) == 2
+    assert int(state.state) == 3
 
 
 async def test_self_referencing_sensor_with_icon_and_picture_entity_loop(hass, caplog):
@@ -872,12 +872,12 @@ async def test_self_referencing_sensor_with_icon_and_picture_entity_loop(hass, c
     assert "Template loop detected" in caplog.text
 
     state = hass.states.get("sensor.test")
-    assert int(state.state) == 3
+    assert int(state.state) == 4
     assert state.attributes[ATTR_ICON] == "mdi:less"
     assert state.attributes[ATTR_ENTITY_PICTURE] == "bigpic"
 
     await hass.async_block_till_done()
-    assert int(state.state) == 3
+    assert int(state.state) == 4
 
 
 async def test_self_referencing_entity_picture_loop(hass, caplog):
@@ -917,7 +917,7 @@ async def test_self_referencing_entity_picture_loop(hass, caplog):
 
     state = hass.states.get("sensor.test")
     assert int(state.state) == 1
-    assert state.attributes[ATTR_ENTITY_PICTURE] == "1"
+    assert state.attributes[ATTR_ENTITY_PICTURE] == "2"
 
     await hass.async_block_till_done()
     assert int(state.state) == 1

From 2707bbeb236f7033526fdb907e72b38fc68fe0c7 Mon Sep 17 00:00:00 2001
From: Alexei Chetroi <lexoid@gmail.com>
Date: Thu, 1 Oct 2020 21:47:33 -0400
Subject: [PATCH 14/82] Better parsing of the ZHA device profile id (#41024)

---
 homeassistant/components/zha/core/device.py | 39 +++++++++------------
 1 file changed, 16 insertions(+), 23 deletions(-)

diff --git a/homeassistant/components/zha/core/device.py b/homeassistant/components/zha/core/device.py
index 04054ebdd05..68fb7393cd5 100644
--- a/homeassistant/components/zha/core/device.py
+++ b/homeassistant/components/zha/core/device.py
@@ -9,7 +9,7 @@ from typing import Any, Dict
 
 from zigpy import types
 import zigpy.exceptions
-from zigpy.profiles import zha, zll
+from zigpy.profiles import PROFILES
 import zigpy.quirks
 from zigpy.zcl.clusters.general import Groups
 import zigpy.zdo.types as zdo_types
@@ -456,27 +456,20 @@ class ZHADevice(LogMixin):
         ]
 
         # Return endpoint device type Names
-        try:
-            device_info[ATTR_ENDPOINT_NAMES] = [
-                {
-                    "name": endpoint.device_type.name,
-                }
-                for (ep_id, endpoint) in self._zigpy_device.endpoints.items()
-                if ep_id != 0
-                and endpoint.profile_id in (zha.PROFILE_ID, zll.PROFILE_ID)
-            ]
-        except AttributeError as ex:
-            # Some device types are not using an enumeration
-            self.warning(
-                "Failed to identify endpoint name in '%s' with exception '%s'",
-                self._zigpy_device.endpoints.items(),
-                ex,
-            )
-            device_info[ATTR_ENDPOINT_NAMES] = [
-                {
-                    "name": "unknown",
-                }
-            ]
+        names = []
+        for endpoint in (ep for epid, ep in self.device.endpoints.items() if epid):
+            profile = PROFILES.get(endpoint.profile_id)
+            if profile and endpoint.device_type is not None:
+                # DeviceType provides undefined enums
+                names.append({ATTR_NAME: profile.DeviceType(endpoint.device_type).name})
+            else:
+                names.append(
+                    {
+                        ATTR_NAME: f"unknown {endpoint.device_type} device_type "
+                        "of 0x{endpoint.profile_id:04x} profile id"
+                    }
+                )
+        device_info[ATTR_ENDPOINT_NAMES] = names
 
         reg_device = self.gateway.ha_device_registry.async_get(self.device_id)
         if reg_device is not None:
@@ -516,7 +509,7 @@ class ZHADevice(LogMixin):
                 CLUSTER_TYPE_OUT: endpoint.out_clusters,
             }
             for (ep_id, endpoint) in self._zigpy_device.endpoints.items()
-            if ep_id != 0 and endpoint.profile_id in (zha.PROFILE_ID, zll.PROFILE_ID)
+            if ep_id != 0 and endpoint.profile_id in PROFILES
         }
 
     @callback

From 1ef3d856a65b61086fc70c279285e7a91dab05f9 Mon Sep 17 00:00:00 2001
From: Marius <33354141+Mariusthvdb@users.noreply.github.com>
Date: Sat, 3 Oct 2020 20:55:00 +0200
Subject: [PATCH 15/82] Change Swap free mandatory arg (#41025)

to False
---
 homeassistant/components/systemmonitor/sensor.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/homeassistant/components/systemmonitor/sensor.py b/homeassistant/components/systemmonitor/sensor.py
index e7ad77e1842..e29081257e0 100644
--- a/homeassistant/components/systemmonitor/sensor.py
+++ b/homeassistant/components/systemmonitor/sensor.py
@@ -87,7 +87,7 @@ SENSOR_TYPES = {
         None,
         False,
     ],
-    "swap_free": ["Swap free", DATA_MEBIBYTES, "mdi:harddisk", None, True],
+    "swap_free": ["Swap free", DATA_MEBIBYTES, "mdi:harddisk", None, False],
     "swap_use": ["Swap use", DATA_MEBIBYTES, "mdi:harddisk", None, False],
     "swap_use_percent": ["Swap use (percent)", PERCENTAGE, "mdi:harddisk", None, False],
 }

From 44b1b87e13ce61dba96ca346ec1792279edb97d8 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Sat, 3 Oct 2020 14:29:41 -0500
Subject: [PATCH 16/82] Ensure lights added after group is created have the
 correct state (#41034)

---
 homeassistant/components/group/__init__.py |  44 ++--
 tests/components/group/test_init.py        | 262 ++++++++++++++++++++-
 2 files changed, 283 insertions(+), 23 deletions(-)

diff --git a/homeassistant/components/group/__init__.py b/homeassistant/components/group/__init__.py
index 28facdb9df0..4a0050868d9 100644
--- a/homeassistant/components/group/__init__.py
+++ b/homeassistant/components/group/__init__.py
@@ -91,6 +91,7 @@ class GroupIntegrationRegistry:
     """Class to hold a registry of integrations."""
 
     on_off_mapping: Dict[str, str] = {STATE_ON: STATE_OFF}
+    off_on_mapping: Dict[str, str] = {STATE_OFF: STATE_ON}
     on_states_by_domain: Dict[str, Set] = {}
     exclude_domains: Set = set()
 
@@ -99,11 +100,14 @@ class GroupIntegrationRegistry:
         self.exclude_domains.add(current_domain.get())
 
     def on_off_states(self, on_states: Set, off_state: str) -> None:
-        """Registry on and off states for the current domain."""
+        """Register on and off states for the current domain."""
         for on_state in on_states:
             if on_state not in self.on_off_mapping:
                 self.on_off_mapping[on_state] = off_state
 
+        if len(on_states) == 1 and off_state not in self.off_on_mapping:
+            self.off_on_mapping[off_state] = list(on_states)[0]
+
         self.on_states_by_domain[current_domain.get()] = set(on_states)
 
 
@@ -543,6 +547,7 @@ class Group(Entity):
         data = {ATTR_ENTITY_ID: self.tracking, ATTR_ORDER: self._order}
         if not self.user_defined:
             data[ATTR_AUTO] = True
+
         return data
 
     @property
@@ -577,6 +582,7 @@ class Group(Entity):
             return
 
         excluded_domains = self.hass.data[REG_KEY].exclude_domains
+
         tracking = []
         trackable = []
         for ent_id in entity_ids:
@@ -592,6 +598,7 @@ class Group(Entity):
     @callback
     def _async_start(self, *_):
         """Start tracking members and write state."""
+        self._reset_tracked_state()
         self._async_start_tracking()
         self.async_write_ha_state()
 
@@ -625,15 +632,14 @@ class Group(Entity):
 
     async def async_added_to_hass(self):
         """Handle addition to Home Assistant."""
-        if self.tracking:
-            self._reset_tracked_state()
-
         if self.hass.state != CoreState.running:
             self.hass.bus.async_listen_once(
                 EVENT_HOMEASSISTANT_START, self._async_start
             )
             return
 
+        if self.tracking:
+            self._reset_tracked_state()
         self._async_start_tracking()
 
     async def async_will_remove_from_hass(self):
@@ -671,19 +677,26 @@ class Group(Entity):
             if state is not None:
                 self._see_state(state)
 
-    def _see_state(self, state):
+    def _see_state(self, new_state):
         """Keep track of the the state."""
-        entity_id = state.entity_id
-        domain = state.domain
+        entity_id = new_state.entity_id
+        domain = new_state.domain
+        state = new_state.state
+        registry = self.hass.data[REG_KEY]
+        self._assumed[entity_id] = new_state.attributes.get(ATTR_ASSUMED_STATE)
 
-        domain_on_state = self.hass.data[REG_KEY].on_states_by_domain.get(
-            domain, {STATE_ON}
-        )
-        self._on_off[entity_id] = state.state in domain_on_state
-        self._assumed[entity_id] = state.attributes.get(ATTR_ASSUMED_STATE)
-
-        if domain in self.hass.data[REG_KEY].on_states_by_domain:
-            self._on_states.update(domain_on_state)
+        if domain not in registry.on_states_by_domain:
+            # Handle the group of a group case
+            if state in registry.on_off_mapping:
+                self._on_states.add(state)
+            elif state in registry.off_on_mapping:
+                self._on_states.add(registry.off_on_mapping[state])
+            self._on_off[entity_id] = state in registry.on_off_mapping
+        else:
+            entity_on_state = registry.on_states_by_domain[domain]
+            if domain in self.hass.data[REG_KEY].on_states_by_domain:
+                self._on_states.update(entity_on_state)
+            self._on_off[entity_id] = state in entity_on_state
 
     @callback
     def _async_update_group_state(self, tr_state=None):
@@ -726,7 +739,6 @@ class Group(Entity):
         # on state, we use STATE_ON/STATE_OFF
         else:
             on_state = STATE_ON
-
         group_is_on = self.mode(self._on_off.values())
         if group_is_on:
             self._state = on_state
diff --git a/tests/components/group/test_init.py b/tests/components/group/test_init.py
index 94f40ad922e..18d37267334 100644
--- a/tests/components/group/test_init.py
+++ b/tests/components/group/test_init.py
@@ -763,7 +763,6 @@ async def test_group_climate_all_cool(hass):
     hass.states.async_set("climate.two", "cool")
     hass.states.async_set("climate.three", "cool")
 
-    assert await async_setup_component(hass, "climate", {})
     assert await async_setup_component(
         hass,
         "group",
@@ -773,6 +772,7 @@ async def test_group_climate_all_cool(hass):
             }
         },
     )
+    assert await async_setup_component(hass, "climate", {})
     await hass.async_block_till_done()
 
     assert hass.states.get("group.group_zero").state == STATE_ON
@@ -804,8 +804,8 @@ async def test_group_alarm(hass):
     hass.states.async_set("alarm_control_panel.one", "armed_away")
     hass.states.async_set("alarm_control_panel.two", "armed_home")
     hass.states.async_set("alarm_control_panel.three", "armed_away")
+    hass.state = CoreState.stopped
 
-    assert await async_setup_component(hass, "alarm_control_panel", {})
     assert await async_setup_component(
         hass,
         "group",
@@ -817,8 +817,10 @@ async def test_group_alarm(hass):
             }
         },
     )
+    assert await async_setup_component(hass, "alarm_control_panel", {})
+    await hass.async_block_till_done()
+    hass.bus.async_fire(EVENT_HOMEASSISTANT_START)
     await hass.async_block_till_done()
-
     assert hass.states.get("group.group_zero").state == STATE_ON
 
 
@@ -850,8 +852,8 @@ async def test_group_vacuum_off(hass):
     hass.states.async_set("vacuum.one", "docked")
     hass.states.async_set("vacuum.two", "off")
     hass.states.async_set("vacuum.three", "off")
+    hass.state = CoreState.stopped
 
-    assert await async_setup_component(hass, "vacuum", {})
     assert await async_setup_component(
         hass,
         "group",
@@ -861,8 +863,11 @@ async def test_group_vacuum_off(hass):
             }
         },
     )
+    assert await async_setup_component(hass, "vacuum", {})
     await hass.async_block_till_done()
 
+    hass.bus.async_fire(EVENT_HOMEASSISTANT_START)
+    await hass.async_block_till_done()
     assert hass.states.get("group.group_zero").state == STATE_OFF
 
 
@@ -893,7 +898,6 @@ async def test_device_tracker_not_home(hass):
     hass.states.async_set("device_tracker.two", "not_home")
     hass.states.async_set("device_tracker.three", "not_home")
 
-    assert await async_setup_component(hass, "device_tracker", {})
     assert await async_setup_component(
         hass,
         "group",
@@ -916,7 +920,6 @@ async def test_light_removed(hass):
     hass.states.async_set("light.two", "off")
     hass.states.async_set("light.three", "on")
 
-    assert await async_setup_component(hass, "light", {})
     assert await async_setup_component(
         hass,
         "group",
@@ -943,7 +946,6 @@ async def test_switch_removed(hass):
     hass.states.async_set("switch.three", "on")
 
     hass.state = CoreState.stopped
-    assert await async_setup_component(hass, "switch", {})
     assert await async_setup_component(
         hass,
         "group",
@@ -956,6 +958,8 @@ async def test_switch_removed(hass):
     await hass.async_block_till_done()
 
     assert hass.states.get("group.group_zero").state == "unknown"
+    assert await async_setup_component(hass, "switch", {})
+    await hass.async_block_till_done()
 
     hass.bus.async_fire(EVENT_HOMEASSISTANT_START)
     await hass.async_block_till_done()
@@ -965,3 +969,247 @@ async def test_switch_removed(hass):
     await hass.async_block_till_done()
 
     assert hass.states.get("group.group_zero").state == "off"
+
+
+async def test_lights_added_after_group(hass):
+    """Test lights added after group."""
+
+    entity_ids = [
+        "light.living_front_ri",
+        "light.living_back_lef",
+        "light.living_back_cen",
+        "light.living_front_le",
+        "light.living_front_ce",
+        "light.living_back_rig",
+    ]
+
+    assert await async_setup_component(
+        hass,
+        "group",
+        {
+            "group": {
+                "living_room_downlights": {"entities": entity_ids},
+            }
+        },
+    )
+    await hass.async_block_till_done()
+
+    assert hass.states.get("group.living_room_downlights").state == "unknown"
+
+    for entity_id in entity_ids:
+        hass.states.async_set(entity_id, "off")
+    await hass.async_block_till_done()
+
+    assert hass.states.get("group.living_room_downlights").state == "off"
+
+
+async def test_lights_added_before_group(hass):
+    """Test lights added before group."""
+
+    entity_ids = [
+        "light.living_front_ri",
+        "light.living_back_lef",
+        "light.living_back_cen",
+        "light.living_front_le",
+        "light.living_front_ce",
+        "light.living_back_rig",
+    ]
+
+    for entity_id in entity_ids:
+        hass.states.async_set(entity_id, "off")
+    await hass.async_block_till_done()
+
+    assert await async_setup_component(
+        hass,
+        "group",
+        {
+            "group": {
+                "living_room_downlights": {"entities": entity_ids},
+            }
+        },
+    )
+    await hass.async_block_till_done()
+
+    assert hass.states.get("group.living_room_downlights").state == "off"
+
+
+async def test_cover_added_after_group(hass):
+    """Test cover added after group."""
+
+    entity_ids = [
+        "cover.upstairs",
+        "cover.downstairs",
+    ]
+
+    assert await async_setup_component(
+        hass,
+        "group",
+        {
+            "group": {
+                "shades": {"entities": entity_ids},
+            }
+        },
+    )
+    await hass.async_block_till_done()
+
+    for entity_id in entity_ids:
+        hass.states.async_set(entity_id, "open")
+    await hass.async_block_till_done()
+    await hass.async_block_till_done()
+
+    assert hass.states.get("group.shades").state == "open"
+
+    for entity_id in entity_ids:
+        hass.states.async_set(entity_id, "closed")
+
+    await hass.async_block_till_done()
+    assert hass.states.get("group.shades").state == "closed"
+
+
+async def test_group_that_references_a_group_of_lights(hass):
+    """Group that references a group of lights."""
+
+    entity_ids = [
+        "light.living_front_ri",
+        "light.living_back_lef",
+    ]
+    hass.state = CoreState.stopped
+
+    for entity_id in entity_ids:
+        hass.states.async_set(entity_id, "off")
+    await hass.async_block_till_done()
+
+    assert await async_setup_component(
+        hass,
+        "group",
+        {
+            "group": {
+                "living_room_downlights": {"entities": entity_ids},
+                "grouped_group": {
+                    "entities": ["group.living_room_downlights", *entity_ids]
+                },
+            }
+        },
+    )
+    await hass.async_block_till_done()
+
+    hass.bus.async_fire(EVENT_HOMEASSISTANT_START)
+    await hass.async_block_till_done()
+
+    assert hass.states.get("group.living_room_downlights").state == "off"
+    assert hass.states.get("group.grouped_group").state == "off"
+
+
+async def test_group_that_references_a_group_of_covers(hass):
+    """Group that references a group of covers."""
+
+    entity_ids = [
+        "cover.living_front_ri",
+        "cover.living_back_lef",
+    ]
+    hass.state = CoreState.stopped
+
+    for entity_id in entity_ids:
+        hass.states.async_set(entity_id, "closed")
+    await hass.async_block_till_done()
+
+    assert await async_setup_component(
+        hass,
+        "group",
+        {
+            "group": {
+                "living_room_downcover": {"entities": entity_ids},
+                "grouped_group": {
+                    "entities": ["group.living_room_downlights", *entity_ids]
+                },
+            }
+        },
+    )
+    await hass.async_block_till_done()
+
+    hass.bus.async_fire(EVENT_HOMEASSISTANT_START)
+    await hass.async_block_till_done()
+
+    assert hass.states.get("group.living_room_downcover").state == "closed"
+    assert hass.states.get("group.grouped_group").state == "closed"
+
+
+async def test_group_that_references_two_groups_of_covers(hass):
+    """Group that references a group of covers."""
+
+    entity_ids = [
+        "cover.living_front_ri",
+        "cover.living_back_lef",
+    ]
+    hass.state = CoreState.stopped
+
+    for entity_id in entity_ids:
+        hass.states.async_set(entity_id, "closed")
+    await hass.async_block_till_done()
+
+    assert await async_setup_component(
+        hass,
+        "group",
+        {
+            "group": {
+                "living_room_downcover": {"entities": entity_ids},
+                "living_room_upcover": {"entities": entity_ids},
+                "grouped_group": {
+                    "entities": [
+                        "group.living_room_downlights",
+                        "group.living_room_upcover",
+                    ]
+                },
+            }
+        },
+    )
+    await hass.async_block_till_done()
+
+    hass.bus.async_fire(EVENT_HOMEASSISTANT_START)
+    await hass.async_block_till_done()
+
+    assert hass.states.get("group.living_room_downcover").state == "closed"
+    assert hass.states.get("group.living_room_upcover").state == "closed"
+    assert hass.states.get("group.grouped_group").state == "closed"
+
+
+async def test_group_that_references_two_types_of_groups(hass):
+    """Group that references a group of covers and device_trackers."""
+
+    group_1_entity_ids = [
+        "cover.living_front_ri",
+        "cover.living_back_lef",
+    ]
+    group_2_entity_ids = [
+        "device_tracker.living_front_ri",
+        "device_tracker.living_back_lef",
+    ]
+    hass.state = CoreState.stopped
+
+    for entity_id in group_1_entity_ids:
+        hass.states.async_set(entity_id, "closed")
+    for entity_id in group_2_entity_ids:
+        hass.states.async_set(entity_id, "home")
+    await hass.async_block_till_done()
+
+    assert await async_setup_component(
+        hass,
+        "group",
+        {
+            "group": {
+                "covers": {"entities": group_1_entity_ids},
+                "device_trackers": {"entities": group_2_entity_ids},
+                "grouped_group": {
+                    "entities": ["group.covers", "group.device_trackers"]
+                },
+            }
+        },
+    )
+    await hass.async_block_till_done()
+
+    hass.bus.async_fire(EVENT_HOMEASSISTANT_START)
+    await hass.async_block_till_done()
+
+    assert hass.states.get("group.covers").state == "closed"
+    assert hass.states.get("group.device_trackers").state == "home"
+    assert hass.states.get("group.grouped_group").state == "on"

From 751f0410099809b81e2bd5aff995984ccdbe778f Mon Sep 17 00:00:00 2001
From: Paulus Schoutsen <balloob@gmail.com>
Date: Fri, 2 Oct 2020 15:27:45 +0200
Subject: [PATCH 17/82] Bump aioshelly to 0.3.4 (#41065)

---
 homeassistant/components/shelly/manifest.json | 4 ++--
 requirements_all.txt                          | 2 +-
 requirements_test_all.txt                     | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/homeassistant/components/shelly/manifest.json b/homeassistant/components/shelly/manifest.json
index 1757bb28d9d..3816d31222e 100644
--- a/homeassistant/components/shelly/manifest.json
+++ b/homeassistant/components/shelly/manifest.json
@@ -3,7 +3,7 @@
   "name": "Shelly",
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/shelly",
-  "requirements": ["aioshelly==0.3.3"],
-  "zeroconf": [{"type": "_http._tcp.local.", "name":"shelly*"}],
+  "requirements": ["aioshelly==0.3.4"],
+  "zeroconf": [{ "type": "_http._tcp.local.", "name": "shelly*" }],
   "codeowners": ["@balloob", "@bieniu"]
 }
diff --git a/requirements_all.txt b/requirements_all.txt
index b973deb1de2..4138cedbea9 100644
--- a/requirements_all.txt
+++ b/requirements_all.txt
@@ -221,7 +221,7 @@ aiopvpc==2.0.2
 aiopylgtv==0.3.3
 
 # homeassistant.components.shelly
-aioshelly==0.3.3
+aioshelly==0.3.4
 
 # homeassistant.components.switcher_kis
 aioswitcher==1.2.1
diff --git a/requirements_test_all.txt b/requirements_test_all.txt
index c8ceb1aa5e2..20ba62e0785 100644
--- a/requirements_test_all.txt
+++ b/requirements_test_all.txt
@@ -134,7 +134,7 @@ aiopvpc==2.0.2
 aiopylgtv==0.3.3
 
 # homeassistant.components.shelly
-aioshelly==0.3.3
+aioshelly==0.3.4
 
 # homeassistant.components.switcher_kis
 aioswitcher==1.2.1

From f114419359052b37210899350b2e9aaa0345f924 Mon Sep 17 00:00:00 2001
From: Samantha <samantha.uk.github@gmail.com>
Date: Fri, 2 Oct 2020 17:18:55 +0100
Subject: [PATCH 18/82] Add full command details to exception Debug log
 (#41070)

---
 homeassistant/components/zha/core/channels/base.py | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/homeassistant/components/zha/core/channels/base.py b/homeassistant/components/zha/core/channels/base.py
index ebc2cd5cd0f..0570070785f 100644
--- a/homeassistant/components/zha/core/channels/base.py
+++ b/homeassistant/components/zha/core/channels/base.py
@@ -57,7 +57,13 @@ def decorate_command(channel, command):
             return result
 
         except (zigpy.exceptions.ZigbeeException, asyncio.TimeoutError) as ex:
-            channel.debug("command failed: %s exception: %s", command.__name__, str(ex))
+            channel.debug(
+                "command failed: '%s' args: '%s' kwargs '%s' exception: '%s'",
+                command.__name__,
+                args,
+                kwds,
+                str(ex),
+            )
             return ex
 
     return wrapper

From 7fc4b196bd63dbe8630f7b18293a08925f90a0d1 Mon Sep 17 00:00:00 2001
From: Baptiste Candellier <outadoc@gmail.com>
Date: Sat, 3 Oct 2020 03:26:08 +0200
Subject: [PATCH 19/82] Fix SmartHab import flow (#41093)

---
 homeassistant/components/smarthab/__init__.py   | 17 ++++++++++-------
 .../components/smarthab/config_flow.py          |  7 +++++--
 2 files changed, 15 insertions(+), 9 deletions(-)

diff --git a/homeassistant/components/smarthab/__init__.py b/homeassistant/components/smarthab/__init__.py
index 2d22841660a..c826b5d8f4d 100644
--- a/homeassistant/components/smarthab/__init__.py
+++ b/homeassistant/components/smarthab/__init__.py
@@ -34,15 +34,18 @@ async def async_setup(hass, config) -> bool:
     """Set up the SmartHab platform."""
 
     hass.data.setdefault(DOMAIN, {})
-    sh_conf = config.get(DOMAIN)
 
-    hass.async_create_task(
-        hass.config_entries.flow.async_init(
-            DOMAIN,
-            context={"source": SOURCE_IMPORT},
-            data=sh_conf,
+    if DOMAIN not in config:
+        return True
+
+    if not hass.config_entries.async_entries(DOMAIN):
+        hass.async_create_task(
+            hass.config_entries.flow.async_init(
+                DOMAIN,
+                context={"source": SOURCE_IMPORT},
+                data=config[DOMAIN],
+            )
         )
-    )
 
     return True
 
diff --git a/homeassistant/components/smarthab/config_flow.py b/homeassistant/components/smarthab/config_flow.py
index f0a1df88695..a277388c140 100644
--- a/homeassistant/components/smarthab/config_flow.py
+++ b/homeassistant/components/smarthab/config_flow.py
@@ -16,6 +16,9 @@ _LOGGER = logging.getLogger(__name__)
 class SmartHabConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
     """SmartHab config flow."""
 
+    VERSION = 1
+    CONNECTION_CLASS = config_entries.CONN_CLASS_CLOUD_POLL
+
     def _show_setup_form(self, user_input=None, errors=None):
         """Show the setup form to the user."""
 
@@ -72,6 +75,6 @@ class SmartHabConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
 
         return self._show_setup_form(user_input, errors)
 
-    async def async_step_import(self, user_input):
+    async def async_step_import(self, import_info):
         """Handle import from legacy config."""
-        return await self.async_step_user(user_input)
+        return await self.async_step_user(import_info)

From 681cd926273de74bdd38214cc1aa0f89ac02f50b Mon Sep 17 00:00:00 2001
From: Franck Nijhof <git@frenck.dev>
Date: Sat, 3 Oct 2020 20:55:59 +0200
Subject: [PATCH 20/82] Fix referenced entity extraction when service call
 entity contains a template (#41107)

---
 homeassistant/helpers/script.py | 2 +-
 tests/helpers/test_script.py    | 4 ++++
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/homeassistant/helpers/script.py b/homeassistant/helpers/script.py
index 717e9c3980c..05808d3bcd5 100644
--- a/homeassistant/helpers/script.py
+++ b/homeassistant/helpers/script.py
@@ -850,7 +850,7 @@ class Script:
 
                 entity_ids = data.get(ATTR_ENTITY_ID)
 
-                if entity_ids is None:
+                if entity_ids is None or isinstance(entity_ids, template.Template):
                     continue
 
                 if isinstance(entity_ids, str):
diff --git a/tests/helpers/test_script.py b/tests/helpers/test_script.py
index 0bd353e1fa0..936866b4306 100644
--- a/tests/helpers/test_script.py
+++ b/tests/helpers/test_script.py
@@ -1332,6 +1332,10 @@ async def test_referenced_entities(hass):
                     "service": "test.script",
                     "data": {"entity_id": ["light.service_list"]},
                 },
+                {
+                    "service": "test.script",
+                    "data": {"entity_id": "{{ 'light.service_template' }}"},
+                },
                 {
                     "condition": "state",
                     "entity_id": "sensor.condition",

From 17ebc85b6282464b2e7da13218dd05d13125ad01 Mon Sep 17 00:00:00 2001
From: Alexei Chetroi <lexoid@gmail.com>
Date: Fri, 2 Oct 2020 21:25:50 -0400
Subject: [PATCH 21/82] Bump up ZHA dependency (#41109)

---
 homeassistant/components/zha/manifest.json | 2 +-
 requirements_all.txt                       | 2 +-
 requirements_test_all.txt                  | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/homeassistant/components/zha/manifest.json b/homeassistant/components/zha/manifest.json
index e76aaf7e0df..a26cd6cc8e6 100644
--- a/homeassistant/components/zha/manifest.json
+++ b/homeassistant/components/zha/manifest.json
@@ -12,7 +12,7 @@
     "zigpy==0.25.0",
     "zigpy-xbee==0.13.0",
     "zigpy-zigate==0.6.2",
-    "zigpy-znp==0.2.0"
+    "zigpy-znp==0.2.1"
   ],
   "codeowners": ["@dmulcahey", "@adminiuga"]
 }
diff --git a/requirements_all.txt b/requirements_all.txt
index 4138cedbea9..a77411f411c 100644
--- a/requirements_all.txt
+++ b/requirements_all.txt
@@ -2329,7 +2329,7 @@ zigpy-xbee==0.13.0
 zigpy-zigate==0.6.2
 
 # homeassistant.components.zha
-zigpy-znp==0.2.0
+zigpy-znp==0.2.1
 
 # homeassistant.components.zha
 zigpy==0.25.0
diff --git a/requirements_test_all.txt b/requirements_test_all.txt
index 20ba62e0785..81b40894e89 100644
--- a/requirements_test_all.txt
+++ b/requirements_test_all.txt
@@ -1086,7 +1086,7 @@ zigpy-xbee==0.13.0
 zigpy-zigate==0.6.2
 
 # homeassistant.components.zha
-zigpy-znp==0.2.0
+zigpy-znp==0.2.1
 
 # homeassistant.components.zha
 zigpy==0.25.0

From abc42efe08252b53f0f85d009085a11a49d05b48 Mon Sep 17 00:00:00 2001
From: Rohan Kapoor <rohan@rohankapoor.com>
Date: Sat, 3 Oct 2020 12:34:52 -0700
Subject: [PATCH 22/82] Treat optional input as optional in ZoneMinder config
 flow (#41156)

---
 homeassistant/components/zoneminder/config_flow.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/homeassistant/components/zoneminder/config_flow.py b/homeassistant/components/zoneminder/config_flow.py
index 1d50e8c1bb1..8b0b94107f3 100644
--- a/homeassistant/components/zoneminder/config_flow.py
+++ b/homeassistant/components/zoneminder/config_flow.py
@@ -60,10 +60,10 @@ class ZoneminderFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
                 {
                     vol.Required(CONF_HOST, default=user_input.get(CONF_HOST)): str,
                     vol.Optional(
-                        CONF_USERNAME, default=user_input.get(CONF_USERNAME)
+                        CONF_USERNAME, default=user_input.get(CONF_USERNAME, "")
                     ): str,
                     vol.Optional(
-                        CONF_PASSWORD, default=user_input.get(CONF_PASSWORD)
+                        CONF_PASSWORD, default=user_input.get(CONF_PASSWORD, "")
                     ): str,
                     vol.Optional(
                         CONF_PATH, default=user_input.get(CONF_PATH, DEFAULT_PATH)

From 5c4ba23ca9b0d97e2a4505b317763ebe4c39763c Mon Sep 17 00:00:00 2001
From: Paulus Schoutsen <balloob@gmail.com>
Date: Sat, 3 Oct 2020 19:43:26 +0000
Subject: [PATCH 23/82] Bumped version to 0.116.0b2

---
 homeassistant/const.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/homeassistant/const.py b/homeassistant/const.py
index 1bf14f332fd..bfad4f9d766 100644
--- a/homeassistant/const.py
+++ b/homeassistant/const.py
@@ -1,7 +1,7 @@
 """Constants used by Home Assistant components."""
 MAJOR_VERSION = 0
 MINOR_VERSION = 116
-PATCH_VERSION = "0b1"
+PATCH_VERSION = "0b2"
 __short_version__ = f"{MAJOR_VERSION}.{MINOR_VERSION}"
 __version__ = f"{__short_version__}.{PATCH_VERSION}"
 REQUIRED_PYTHON_VER = (3, 7, 1)

From 37acf9b1659a8068c0c65d6bb7448cebea4a4eb1 Mon Sep 17 00:00:00 2001
From: Simone Chemelli <simone.chemelli@gmail.com>
Date: Thu, 1 Oct 2020 12:07:18 +0200
Subject: [PATCH 24/82] Handle Shelly channel names (if available) for emeters
 devices (#40820)

---
 homeassistant/components/shelly/entity.py | 22 ++++++++++++++++++----
 1 file changed, 18 insertions(+), 4 deletions(-)

diff --git a/homeassistant/components/shelly/entity.py b/homeassistant/components/shelly/entity.py
index 96c35eecbf1..237deec4da1 100644
--- a/homeassistant/components/shelly/entity.py
+++ b/homeassistant/components/shelly/entity.py
@@ -23,7 +23,12 @@ def temperature_unit(block_info: dict) -> str:
 def shelly_naming(self, block, entity_type: str):
     """Naming for switch and sensors."""
 
+    entity_name = self.wrapper.name
+    if not block:
+        return f"{entity_name} {self.description.name}"
+
     channels = 0
+    mode = "relays"
     if "num_outputs" in self.wrapper.device.shelly:
         channels = self.wrapper.device.shelly["num_outputs"]
         if (
@@ -31,12 +36,21 @@ def shelly_naming(self, block, entity_type: str):
             and self.wrapper.device.settings["mode"] == "roller"
         ):
             channels = 1
-
-    entity_name = self.wrapper.name
+        if block.type == "emeter" and "num_emeters" in self.wrapper.device.shelly:
+            channels = self.wrapper.device.shelly["num_emeters"]
+            mode = "emeters"
     if channels > 1 and block.type != "device":
-        entity_name = self.wrapper.device.settings["relays"][int(block.channel)]["name"]
+        # Shelly EM (SHEM) with firmware v1.8.1 doesn't have "name" key; will be fixed in next firmware release
+        if "name" in self.wrapper.device.settings[mode][int(block.channel)]:
+            entity_name = self.wrapper.device.settings[mode][int(block.channel)]["name"]
+        else:
+            entity_name = None
         if not entity_name:
-            entity_name = f"{self.wrapper.name} channel {int(block.channel)+1}"
+            if self.wrapper.model == "SHEM-3":
+                base = ord("A")
+            else:
+                base = ord("1")
+            entity_name = f"{self.wrapper.name} channel {chr(int(block.channel)+base)}"
 
     if entity_type == "switch":
         return entity_name

From 149cc5cbeb68fe6af5c7e9157b66d6c97e4eec25 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Fri, 2 Oct 2020 07:27:39 -0500
Subject: [PATCH 25/82] Simplify template tracking and make it easier to follow
 (#41030)

---
 homeassistant/helpers/event.py | 134 ++++++++++++++++++++-------------
 1 file changed, 81 insertions(+), 53 deletions(-)

diff --git a/homeassistant/helpers/event.py b/homeassistant/helpers/event.py
index 52a43fca3ff..d143ed1d106 100644
--- a/homeassistant/helpers/event.py
+++ b/homeassistant/helpers/event.py
@@ -774,16 +774,65 @@ class _TrackTemplateResultInfo:
         """Force recalculate the template."""
         self._refresh(None)
 
-    @callback
-    def _event_triggers_template(self, template: Template, event: Event) -> bool:
-        """Determine if a template should be re-rendered from an event."""
-        entity_id = event.data.get(ATTR_ENTITY_ID)
-        return (
-            self._info[template].filter(entity_id)
-            or event.data.get("new_state") is None
-            or event.data.get("old_state") is None
-            and self._info[template].filter_lifecycle(entity_id)
-        )
+    def _render_template_if_ready(
+        self,
+        track_template_: TrackTemplate,
+        now: datetime,
+        event: Optional[Event],
+    ) -> Union[bool, TrackTemplateResult]:
+        """Re-render the template if conditions match.
+
+        Returns False if the template was not be re-rendered
+
+        Returns True if the template re-rendered and did not
+        change.
+
+        Returns TrackTemplateResult if the template re-render
+        generates a new result.
+        """
+        template = track_template_.template
+
+        if event:
+            info = self._info[template]
+
+            if not self._rate_limit.async_has_timer(
+                template
+            ) and not _event_triggers_rerender(event, info):
+                return False
+
+            if self._rate_limit.async_schedule_action(
+                template,
+                info.rate_limit or track_template_.rate_limit,
+                now,
+                self._refresh,
+                event,
+            ):
+                return False
+
+            _LOGGER.debug(
+                "Template update %s triggered by event: %s",
+                template.template,
+                event,
+            )
+
+        self._rate_limit.async_triggered(template, now)
+        self._info[template] = template.async_render_to_info(track_template_.variables)
+
+        try:
+            result: Union[str, TemplateError] = self._info[template].result()
+        except TemplateError as ex:
+            result = ex
+
+        last_result = self._last_result.get(template)
+
+        # Check to see if the result has changed
+        if result == last_result:
+            return True
+
+        if isinstance(result, TemplateError) and isinstance(last_result, TemplateError):
+            return True
+
+        return TrackTemplateResult(template, last_result, result)
 
     @callback
     def _refresh(self, event: Optional[Event]) -> None:
@@ -792,51 +841,13 @@ class _TrackTemplateResultInfo:
         now = dt_util.utcnow()
 
         for track_template_ in self._track_templates:
-            template = track_template_.template
-            if event:
-                if not self._rate_limit.async_has_timer(
-                    template
-                ) and not self._event_triggers_template(template, event):
-                    continue
+            update = self._render_template_if_ready(track_template_, now, event)
+            if not update:
+                continue
 
-                if self._rate_limit.async_schedule_action(
-                    template,
-                    self._info[template].rate_limit or track_template_.rate_limit,
-                    now,
-                    self._refresh,
-                    event,
-                ):
-                    continue
-
-                _LOGGER.debug(
-                    "Template update %s triggered by event: %s",
-                    template.template,
-                    event,
-                )
-
-            self._rate_limit.async_triggered(template, now)
-            self._info[template] = template.async_render_to_info(
-                track_template_.variables
-            )
             info_changed = True
-
-            try:
-                result: Union[str, TemplateError] = self._info[template].result()
-            except TemplateError as ex:
-                result = ex
-
-            last_result = self._last_result.get(template)
-
-            # Check to see if the result has changed
-            if result == last_result:
-                continue
-
-            if isinstance(result, TemplateError) and isinstance(
-                last_result, TemplateError
-            ):
-                continue
-
-            updates.append(TrackTemplateResult(template, last_result, result))
+            if isinstance(update, TrackTemplateResult):
+                updates.append(update)
 
         if info_changed:
             assert self._track_state_changes
@@ -1348,3 +1359,20 @@ def _render_infos_to_track_states(render_infos: Iterable[RenderInfo]) -> TrackSt
         return TrackStates(True, set(), set())
 
     return TrackStates(False, *_entities_domains_from_render_infos(render_infos))
+
+
+@callback
+def _event_triggers_rerender(event: Event, info: RenderInfo) -> bool:
+    """Determine if a template should be re-rendered from an event."""
+    entity_id = event.data.get(ATTR_ENTITY_ID)
+
+    if info.filter(entity_id):
+        return True
+
+    if (
+        event.data.get("new_state") is not None
+        and event.data.get("old_state") is not None
+    ):
+        return False
+
+    return bool(info.filter_lifecycle(entity_id))

From 6e3aa004c4d77d55e9f438eb3e98f2777739c14e Mon Sep 17 00:00:00 2001
From: Justin Paupore <jpaupore@google.com>
Date: Sun, 4 Oct 2020 02:59:53 -0700
Subject: [PATCH 26/82] Fix TTS handling of non-ID3 metadata tags (#41191)

Change #40666 used mutagen's ID3 TextFrame to wrap metadata information.
While this is the correct behavior for container formats that use ID3
metadata tags, such as MP3 and linear PCM, Ogg container formats use
a different metadata format. For these containers, the metadata needs to
be a bare str, not wrapped in a TextFrame.
---
 homeassistant/components/tts/__init__.py | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/homeassistant/components/tts/__init__.py b/homeassistant/components/tts/__init__.py
index 2eb12750fe8..e8e07092ce5 100644
--- a/homeassistant/components/tts/__init__.py
+++ b/homeassistant/components/tts/__init__.py
@@ -11,7 +11,7 @@ from typing import Dict, Optional
 
 from aiohttp import web
 import mutagen
-from mutagen.id3 import TextFrame as ID3Text
+from mutagen.id3 import ID3, TextFrame as ID3Text
 import voluptuous as vol
 
 from homeassistant.components.http import HomeAssistantView
@@ -468,9 +468,14 @@ class SpeechManager:
         try:
             tts_file = mutagen.File(data_bytes)
             if tts_file is not None:
-                tts_file["artist"] = ID3Text(encoding=3, text=artist)
-                tts_file["album"] = ID3Text(encoding=3, text=album)
-                tts_file["title"] = ID3Text(encoding=3, text=message)
+                if isinstance(tts_file.tags, ID3):
+                    tts_file["artist"] = ID3Text(encoding=3, text=artist)
+                    tts_file["album"] = ID3Text(encoding=3, text=album)
+                    tts_file["title"] = ID3Text(encoding=3, text=message)
+                else:
+                    tts_file["artist"] = artist
+                    tts_file["album"] = album
+                    tts_file["title"] = message
                 tts_file.save(data_bytes)
         except mutagen.MutagenError as err:
             _LOGGER.error("ID3 tag error: %s", err)

From d4b40154e5c0cee39b6478e4599e0c31ee094b29 Mon Sep 17 00:00:00 2001
From: Franck Nijhof <git@frenck.dev>
Date: Sun, 4 Oct 2020 12:54:03 +0200
Subject: [PATCH 27/82] Remove deprecation invalidation version from cast
 integration (#41197)

---
 homeassistant/components/cast/media_player.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/homeassistant/components/cast/media_player.py b/homeassistant/components/cast/media_player.py
index 788da18e8bd..76b6bd17f40 100644
--- a/homeassistant/components/cast/media_player.py
+++ b/homeassistant/components/cast/media_player.py
@@ -86,7 +86,7 @@ SUPPORT_CAST = (
 
 
 ENTITY_SCHEMA = vol.All(
-    cv.deprecated(CONF_HOST, invalidation_version="0.116"),
+    cv.deprecated(CONF_HOST),
     vol.Schema(
         {
             vol.Exclusive(CONF_HOST, "device_identifier"): cv.string,
@@ -97,7 +97,7 @@ ENTITY_SCHEMA = vol.All(
 )
 
 PLATFORM_SCHEMA = vol.All(
-    cv.deprecated(CONF_HOST, invalidation_version="0.116"),
+    cv.deprecated(CONF_HOST),
     PLATFORM_SCHEMA.extend(
         {
             vol.Exclusive(CONF_HOST, "device_identifier"): cv.string,

From 228de5807cfc8850cc9863b651d19c8613ba43af Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Sun, 4 Oct 2020 15:40:04 -0500
Subject: [PATCH 28/82] Remove manual rate_limit control directive from
 templates (#41225)

Increase default rate limit for all states and entire
domain states to one minute

Ensure specifically referenced entities are excluded from
the rate limit
---
 homeassistant/helpers/event.py    |  21 +++-
 homeassistant/helpers/template.py |  25 +---
 tests/helpers/test_event.py       | 196 +++++-------------------------
 tests/helpers/test_template.py    |  27 +---
 4 files changed, 51 insertions(+), 218 deletions(-)

diff --git a/homeassistant/helpers/event.py b/homeassistant/helpers/event.py
index d143ed1d106..b6d59bb500c 100644
--- a/homeassistant/helpers/event.py
+++ b/homeassistant/helpers/event.py
@@ -802,7 +802,7 @@ class _TrackTemplateResultInfo:
 
             if self._rate_limit.async_schedule_action(
                 template,
-                info.rate_limit or track_template_.rate_limit,
+                _rate_limit_for_event(event, info, track_template_),
                 now,
                 self._refresh,
                 event,
@@ -1376,3 +1376,22 @@ def _event_triggers_rerender(event: Event, info: RenderInfo) -> bool:
         return False
 
     return bool(info.filter_lifecycle(entity_id))
+
+
+@callback
+def _rate_limit_for_event(
+    event: Event, info: RenderInfo, track_template_: TrackTemplate
+) -> Optional[timedelta]:
+    """Determine the rate limit for an event."""
+    entity_id = event.data.get(ATTR_ENTITY_ID)
+
+    # Specifically referenced entities are excluded
+    # from the rate limit
+    if entity_id in info.entities:
+        return None
+
+    if track_template_.rate_limit is not None:
+        return track_template_.rate_limit
+
+    rate_limit: Optional[timedelta] = info.rate_limit
+    return rate_limit
diff --git a/homeassistant/helpers/template.py b/homeassistant/helpers/template.py
index b877e0b0e12..c0ceb17fdd7 100644
--- a/homeassistant/helpers/template.py
+++ b/homeassistant/helpers/template.py
@@ -72,7 +72,7 @@ _COLLECTABLE_STATE_ATTRIBUTES = {
     "name",
 }
 
-DEFAULT_RATE_LIMIT = timedelta(seconds=1)
+DEFAULT_RATE_LIMIT = timedelta(minutes=1)
 
 
 @bind_hass
@@ -489,26 +489,6 @@ class Template:
         return 'Template("' + self.template + '")'
 
 
-class RateLimit:
-    """Class to control update rate limits."""
-
-    def __init__(self, hass: HomeAssistantType):
-        """Initialize rate limit."""
-        self._hass = hass
-
-    def __call__(self, *args: Any, **kwargs: Any) -> str:
-        """Handle a call to the class."""
-        render_info = self._hass.data.get(_RENDER_INFO)
-        if render_info is not None:
-            render_info.rate_limit = timedelta(*args, **kwargs)
-
-        return ""
-
-    def __repr__(self) -> str:
-        """Representation of a RateLimit."""
-        return "<template RateLimit>"
-
-
 class AllStates:
     """Class to expose all HA states as attributes."""
 
@@ -1310,11 +1290,10 @@ class TemplateEnvironment(ImmutableSandboxedEnvironment):
         self.globals["is_state_attr"] = hassfunction(is_state_attr)
         self.globals["state_attr"] = hassfunction(state_attr)
         self.globals["states"] = AllStates(hass)
-        self.globals["rate_limit"] = RateLimit(hass)
 
     def is_safe_callable(self, obj):
         """Test if callback is safe."""
-        return isinstance(obj, (AllStates, RateLimit)) or super().is_safe_callable(obj)
+        return isinstance(obj, AllStates) or super().is_safe_callable(obj)
 
     def is_safe_attribute(self, obj, attr, value):
         """Test if attribute is safe."""
diff --git a/tests/helpers/test_event.py b/tests/helpers/test_event.py
index 32d203ddc6e..bf0efaf8cf6 100644
--- a/tests/helpers/test_event.py
+++ b/tests/helpers/test_event.py
@@ -927,7 +927,6 @@ async def test_track_template_result_complex(hass):
     """Test tracking template."""
     specific_runs = []
     template_complex_str = """
-{{ rate_limit(seconds=0) }}
 {% if states("sensor.domain") == "light" %}
   {{ states.light | map(attribute='entity_id') | list }}
 {% elif states("sensor.domain") == "lock" %}
@@ -948,7 +947,9 @@ async def test_track_template_result_complex(hass):
     hass.states.async_set("lock.one", "locked")
 
     info = async_track_template_result(
-        hass, [TrackTemplate(template_complex, None)], specific_run_callback
+        hass,
+        [TrackTemplate(template_complex, None, timedelta(seconds=0))],
+        specific_run_callback,
     )
     await hass.async_block_till_done()
 
@@ -1236,7 +1237,7 @@ async def test_track_template_result_iterator(hass):
         [
             TrackTemplate(
                 Template(
-                    """{{ rate_limit(seconds=0) }}
+                    """
             {% for state in states.sensor %}
                 {% if state.state == 'on' %}
                     {{ state.entity_id }},
@@ -1246,6 +1247,7 @@ async def test_track_template_result_iterator(hass):
                     hass,
                 ),
                 None,
+                timedelta(seconds=0),
             )
         ],
         iterator_callback,
@@ -1268,11 +1270,12 @@ async def test_track_template_result_iterator(hass):
         [
             TrackTemplate(
                 Template(
-                    """{{ rate_limit(seconds=0) }}{{ states.sensor|selectattr("state","equalto","on")
+                    """{{ states.sensor|selectattr("state","equalto","on")
                 |join(",", attribute="entity_id") }}""",
                     hass,
                 ),
                 None,
+                timedelta(seconds=0),
             )
         ],
         filter_callback,
@@ -1452,62 +1455,6 @@ async def test_track_template_rate_limit(hass):
     assert refresh_runs == ["0", "1", "2", "4"]
 
 
-async def test_track_template_rate_limit_overridden(hass):
-    """Test template rate limit can be overridden from the template."""
-    template_refresh = Template(
-        "{% set x = rate_limit(seconds=0.1) %}{{ states | count }}", hass
-    )
-
-    refresh_runs = []
-
-    @ha.callback
-    def refresh_listener(event, updates):
-        refresh_runs.append(updates.pop().result)
-
-    info = async_track_template_result(
-        hass,
-        [TrackTemplate(template_refresh, None, timedelta(seconds=5))],
-        refresh_listener,
-    )
-    await hass.async_block_till_done()
-    info.async_refresh()
-    await hass.async_block_till_done()
-
-    assert refresh_runs == ["0"]
-    hass.states.async_set("sensor.one", "any")
-    await hass.async_block_till_done()
-    assert refresh_runs == ["0"]
-    info.async_refresh()
-    assert refresh_runs == ["0", "1"]
-    hass.states.async_set("sensor.two", "any")
-    await hass.async_block_till_done()
-    assert refresh_runs == ["0", "1"]
-    next_time = dt_util.utcnow() + timedelta(seconds=0.125)
-    with patch(
-        "homeassistant.helpers.ratelimit.dt_util.utcnow", return_value=next_time
-    ):
-        async_fire_time_changed(hass, next_time)
-        await hass.async_block_till_done()
-    assert refresh_runs == ["0", "1", "2"]
-    hass.states.async_set("sensor.three", "any")
-    await hass.async_block_till_done()
-    assert refresh_runs == ["0", "1", "2"]
-    hass.states.async_set("sensor.four", "any")
-    await hass.async_block_till_done()
-    assert refresh_runs == ["0", "1", "2"]
-    next_time = dt_util.utcnow() + timedelta(seconds=0.125 * 2)
-    with patch(
-        "homeassistant.helpers.ratelimit.dt_util.utcnow", return_value=next_time
-    ):
-        async_fire_time_changed(hass, next_time)
-        await hass.async_block_till_done()
-    await hass.async_block_till_done()
-    assert refresh_runs == ["0", "1", "2", "4"]
-    hass.states.async_set("sensor.five", "any")
-    await hass.async_block_till_done()
-    assert refresh_runs == ["0", "1", "2", "4"]
-
-
 async def test_track_template_rate_limit_five(hass):
     """Test template rate limit of 5 seconds."""
     template_refresh = Template("{{ states | count }}", hass)
@@ -1541,19 +1488,11 @@ async def test_track_template_rate_limit_five(hass):
     assert refresh_runs == ["0", "1"]
 
 
-async def test_track_template_rate_limit_changes(hass):
-    """Test template rate limit can be changed."""
-    template_refresh = Template(
-        """
-        {% if states.sensor.two.state == "any" %}
-            {% set x = rate_limit(seconds=5) %}
-        {% else %}
-            {% set x = rate_limit(seconds=0.1) %}
-        {% endif %}
-        {{ states | count }}
-        """,
-        hass,
-    )
+async def test_specifically_referenced_entity_is_not_rate_limited(hass):
+    """Test template rate limit of 5 seconds."""
+    hass.states.async_set("sensor.one", "none")
+
+    template_refresh = Template('{{ states | count }}_{{ states("sensor.one") }}', hass)
 
     refresh_runs = []
 
@@ -1563,114 +1502,34 @@ async def test_track_template_rate_limit_changes(hass):
 
     info = async_track_template_result(
         hass,
-        [TrackTemplate(template_refresh, None)],
+        [TrackTemplate(template_refresh, None, timedelta(seconds=5))],
         refresh_listener,
     )
     await hass.async_block_till_done()
     info.async_refresh()
     await hass.async_block_till_done()
 
-    assert refresh_runs == ["0"]
+    assert refresh_runs == ["1_none"]
     hass.states.async_set("sensor.one", "any")
     await hass.async_block_till_done()
-    assert refresh_runs == ["0"]
+    assert refresh_runs == ["1_none", "1_any"]
     info.async_refresh()
-    assert refresh_runs == ["0", "1"]
+    assert refresh_runs == ["1_none", "1_any"]
     hass.states.async_set("sensor.two", "any")
     await hass.async_block_till_done()
-    assert refresh_runs == ["0", "1"]
-    next_time = dt_util.utcnow() + timedelta(seconds=0.125 * 1)
-    with patch(
-        "homeassistant.helpers.ratelimit.dt_util.utcnow", return_value=next_time
-    ):
-        async_fire_time_changed(hass, next_time)
-        await hass.async_block_till_done()
-    await hass.async_block_till_done()
-    assert refresh_runs == ["0", "1", "2"]
+    assert refresh_runs == ["1_none", "1_any"]
     hass.states.async_set("sensor.three", "any")
     await hass.async_block_till_done()
-    assert refresh_runs == ["0", "1", "2"]
-    hass.states.async_set("sensor.four", "any")
+    assert refresh_runs == ["1_none", "1_any"]
+    hass.states.async_set("sensor.one", "none")
     await hass.async_block_till_done()
-    assert refresh_runs == ["0", "1", "2"]
-    next_time = dt_util.utcnow() + timedelta(seconds=0.125 * 2)
-    with patch(
-        "homeassistant.helpers.ratelimit.dt_util.utcnow", return_value=next_time
-    ):
-        async_fire_time_changed(hass, next_time)
-        await hass.async_block_till_done()
-    await hass.async_block_till_done()
-    assert refresh_runs == ["0", "1", "2"]
-    hass.states.async_set("sensor.five", "any")
-    await hass.async_block_till_done()
-    assert refresh_runs == ["0", "1", "2"]
-
-
-async def test_track_template_rate_limit_removed(hass):
-    """Test template rate limit can be removed."""
-    template_refresh = Template(
-        """
-        {% if states.sensor.two.state == "any" %}
-            {% set x = rate_limit(0) %}
-        {% else %}
-            {% set x = rate_limit(seconds=0.1) %}
-        {% endif %}
-        {{ states | count }}
-        """,
-        hass,
-    )
-
-    refresh_runs = []
-
-    @ha.callback
-    def refresh_listener(event, updates):
-        refresh_runs.append(updates.pop().result)
-
-    info = async_track_template_result(
-        hass,
-        [TrackTemplate(template_refresh, None)],
-        refresh_listener,
-    )
-    await hass.async_block_till_done()
-    info.async_refresh()
-    await hass.async_block_till_done()
-
-    assert refresh_runs == ["0"]
-    hass.states.async_set("sensor.one", "any")
-    await hass.async_block_till_done()
-    assert refresh_runs == ["0"]
-    info.async_refresh()
-    assert refresh_runs == ["0", "1"]
-    hass.states.async_set("sensor.two", "any")
-    await hass.async_block_till_done()
-    assert refresh_runs == ["0", "1"]
-    next_time = dt_util.utcnow() + timedelta(seconds=0.125 * 1)
-    with patch(
-        "homeassistant.helpers.ratelimit.dt_util.utcnow", return_value=next_time
-    ):
-        async_fire_time_changed(hass, next_time)
-        await hass.async_block_till_done()
-    await hass.async_block_till_done()
-    assert refresh_runs == ["0", "1", "2"]
-    hass.states.async_set("sensor.three", "any")
-    await hass.async_block_till_done()
-    assert refresh_runs == ["0", "1", "2", "3"]
-    hass.states.async_set("sensor.four", "any")
-    await hass.async_block_till_done()
-    assert refresh_runs == ["0", "1", "2", "3", "4"]
-    hass.states.async_set("sensor.five", "any")
-    await hass.async_block_till_done()
-    assert refresh_runs == ["0", "1", "2", "3", "4", "5"]
+    assert refresh_runs == ["1_none", "1_any", "3_none"]
 
 
 async def test_track_two_templates_with_different_rate_limits(hass):
     """Test two templates with different rate limits."""
-    template_one = Template(
-        "{% set x = rate_limit(seconds=0.1) %}{{ states | count }}", hass
-    )
-    template_five = Template(
-        "{% set x = rate_limit(seconds=5) %}{{ states | count }}", hass
-    )
+    template_one = Template("{{ states | count }} ", hass)
+    template_five = Template("{{ states | count }}", hass)
 
     refresh_runs = {
         template_one: [],
@@ -1684,7 +1543,10 @@ async def test_track_two_templates_with_different_rate_limits(hass):
 
     info = async_track_template_result(
         hass,
-        [TrackTemplate(template_one, None), TrackTemplate(template_five, None)],
+        [
+            TrackTemplate(template_one, None, timedelta(seconds=0.1)),
+            TrackTemplate(template_five, None, timedelta(seconds=5)),
+        ],
         refresh_listener,
     )
 
@@ -1867,9 +1729,7 @@ async def test_async_track_template_result_multiple_templates_mixing_domain(hass
     template_1 = Template("{{ states.switch.test.state == 'on' }}")
     template_2 = Template("{{ states.switch.test.state == 'on' }}")
     template_3 = Template("{{ states.switch.test.state == 'off' }}")
-    template_4 = Template(
-        "{{ rate_limit(seconds=0) }}{{ states.switch | map(attribute='entity_id') | list }}"
-    )
+    template_4 = Template("{{ states.switch | map(attribute='entity_id') | list }}")
 
     refresh_runs = []
 
@@ -1883,7 +1743,7 @@ async def test_async_track_template_result_multiple_templates_mixing_domain(hass
             TrackTemplate(template_1, None),
             TrackTemplate(template_2, None),
             TrackTemplate(template_3, None),
-            TrackTemplate(template_4, None),
+            TrackTemplate(template_4, None, timedelta(seconds=0)),
         ],
         refresh_listener,
     )
diff --git a/tests/helpers/test_template.py b/tests/helpers/test_template.py
index 0a5735a98ff..7d39675bdc0 100644
--- a/tests/helpers/test_template.py
+++ b/tests/helpers/test_template.py
@@ -1,5 +1,5 @@
 """Test Home Assistant template helper methods."""
-from datetime import datetime, timedelta
+from datetime import datetime
 import math
 import random
 
@@ -2617,28 +2617,3 @@ async def test_unavailable_states(hass):
         hass,
     )
     assert tpl.async_render() == "light.none, light.unavailable, light.unknown"
-
-
-async def test_rate_limit(hass):
-    """Test we can pickup a rate limit directive."""
-    tmp = template.Template("{{ states | count }}", hass)
-
-    info = tmp.async_render_to_info()
-    assert info.rate_limit is None
-
-    tmp = template.Template("{{ rate_limit(minutes=1) }}{{ states | count }}", hass)
-
-    info = tmp.async_render_to_info()
-    assert info.rate_limit == timedelta(minutes=1)
-
-    tmp = template.Template("{{ rate_limit(minutes=1) }}random", hass)
-
-    info = tmp.async_render_to_info()
-    assert info.result() == "random"
-    assert info.rate_limit == timedelta(minutes=1)
-
-    tmp = template.Template("{{ rate_limit(seconds=0) }}random", hass)
-
-    info = tmp.async_render_to_info()
-    assert info.result() == "random"
-    assert info.rate_limit == timedelta(seconds=0)

From a6d50ba89b7e0cf034f1e616915f34938ee063f9 Mon Sep 17 00:00:00 2001
From: Raman Gupta <7243222+raman325@users.noreply.github.com>
Date: Mon, 5 Oct 2020 04:24:18 -0400
Subject: [PATCH 29/82] Bump apprise version to avoid sync in async issues
 (#41253)

---
 homeassistant/components/apprise/manifest.json | 2 +-
 homeassistant/components/apprise/notify.py     | 6 +-----
 requirements_all.txt                           | 2 +-
 requirements_test_all.txt                      | 2 +-
 4 files changed, 4 insertions(+), 8 deletions(-)

diff --git a/homeassistant/components/apprise/manifest.json b/homeassistant/components/apprise/manifest.json
index beb3a80ceeb..34061120322 100644
--- a/homeassistant/components/apprise/manifest.json
+++ b/homeassistant/components/apprise/manifest.json
@@ -2,6 +2,6 @@
   "domain": "apprise",
   "name": "Apprise",
   "documentation": "https://www.home-assistant.io/integrations/apprise",
-  "requirements": ["apprise==0.8.8"],
+  "requirements": ["apprise==0.8.9"],
   "codeowners": ["@caronc"]
 }
diff --git a/homeassistant/components/apprise/notify.py b/homeassistant/components/apprise/notify.py
index f999da94531..95bf11ddc09 100644
--- a/homeassistant/components/apprise/notify.py
+++ b/homeassistant/components/apprise/notify.py
@@ -28,12 +28,8 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
 
 def get_service(hass, config, discovery_info=None):
     """Get the Apprise notification service."""
-
-    # Create our Apprise Asset Object
-    asset = apprise.AppriseAsset(async_mode=False)
-
     # Create our Apprise Instance (reference our asset)
-    a_obj = apprise.Apprise(asset=asset)
+    a_obj = apprise.Apprise()
 
     if config.get(CONF_FILE):
         # Sourced from a Configuration File
diff --git a/requirements_all.txt b/requirements_all.txt
index a77411f411c..b9f69e7c1ce 100644
--- a/requirements_all.txt
+++ b/requirements_all.txt
@@ -263,7 +263,7 @@ apcaccess==0.0.13
 apns2==0.3.0
 
 # homeassistant.components.apprise
-apprise==0.8.8
+apprise==0.8.9
 
 # homeassistant.components.aprs
 aprslib==0.6.46
diff --git a/requirements_test_all.txt b/requirements_test_all.txt
index 81b40894e89..b597d0997af 100644
--- a/requirements_test_all.txt
+++ b/requirements_test_all.txt
@@ -158,7 +158,7 @@ androidtv[async]==0.0.50
 apns2==0.3.0
 
 # homeassistant.components.apprise
-apprise==0.8.8
+apprise==0.8.9
 
 # homeassistant.components.aprs
 aprslib==0.6.46

From b524cc9c56d320e11bdc63ca952fd06f71df672e Mon Sep 17 00:00:00 2001
From: Paulus Schoutsen <balloob@gmail.com>
Date: Mon, 5 Oct 2020 12:53:12 +0200
Subject: [PATCH 30/82] Allow any value when triggering on state attribute
 (#41261)

---
 .../homeassistant/triggers/state.py           | 37 +++++++++++---
 homeassistant/helpers/condition.py            | 13 +++--
 homeassistant/helpers/config_validation.py    | 50 +++++++++++++------
 .../homeassistant/triggers/test_state.py      | 29 +++++++++++
 tests/helpers/test_condition.py               | 29 ++++++++++-
 5 files changed, 131 insertions(+), 27 deletions(-)

diff --git a/homeassistant/components/homeassistant/triggers/state.py b/homeassistant/components/homeassistant/triggers/state.py
index a7377ffe43e..915856951d2 100644
--- a/homeassistant/components/homeassistant/triggers/state.py
+++ b/homeassistant/components/homeassistant/triggers/state.py
@@ -1,7 +1,7 @@
 """Offer state listening automation rules."""
 from datetime import timedelta
 import logging
-from typing import Dict, Optional
+from typing import Any, Dict, Optional
 
 import voluptuous as vol
 
@@ -25,18 +25,43 @@ CONF_ENTITY_ID = "entity_id"
 CONF_FROM = "from"
 CONF_TO = "to"
 
-TRIGGER_SCHEMA = vol.Schema(
+BASE_SCHEMA = {
+    vol.Required(CONF_PLATFORM): "state",
+    vol.Required(CONF_ENTITY_ID): cv.entity_ids,
+    vol.Optional(CONF_FOR): cv.positive_time_period_template,
+    vol.Optional(CONF_ATTRIBUTE): cv.match_all,
+}
+
+TRIGGER_STATE_SCHEMA = vol.Schema(
     {
-        vol.Required(CONF_PLATFORM): "state",
-        vol.Required(CONF_ENTITY_ID): cv.entity_ids,
+        **BASE_SCHEMA,
         # These are str on purpose. Want to catch YAML conversions
         vol.Optional(CONF_FROM): vol.Any(str, [str]),
         vol.Optional(CONF_TO): vol.Any(str, [str]),
-        vol.Optional(CONF_FOR): cv.positive_time_period_template,
-        vol.Optional(CONF_ATTRIBUTE): cv.match_all,
     }
 )
 
+TRIGGER_ATTRIBUTE_SCHEMA = vol.Schema(
+    {
+        **BASE_SCHEMA,
+        vol.Optional(CONF_FROM): cv.match_all,
+        vol.Optional(CONF_TO): cv.match_all,
+    }
+)
+
+
+def TRIGGER_SCHEMA(value: Any) -> dict:  # pylint: disable=invalid-name
+    """Validate trigger."""
+    if not isinstance(value, dict):
+        raise vol.Invalid("Expected a dictionary")
+
+    # We use this approach instead of vol.Any because
+    # this gives better error messages.
+    if CONF_ATTRIBUTE in value:
+        return TRIGGER_ATTRIBUTE_SCHEMA(value)
+
+    return TRIGGER_STATE_SCHEMA(value)
+
 
 async def async_attach_trigger(
     hass: HomeAssistant,
diff --git a/homeassistant/helpers/condition.py b/homeassistant/helpers/condition.py
index f67b9a4b0ab..c982b58d8d9 100644
--- a/homeassistant/helpers/condition.py
+++ b/homeassistant/helpers/condition.py
@@ -297,7 +297,7 @@ def async_numeric_state_from_config(
 def state(
     hass: HomeAssistant,
     entity: Union[None, str, State],
-    req_state: Union[str, List[str]],
+    req_state: Any,
     for_period: Optional[timedelta] = None,
     attribute: Optional[str] = None,
 ) -> bool:
@@ -314,17 +314,20 @@ def state(
     assert isinstance(entity, State)
 
     if attribute is None:
-        value = entity.state
+        value: Any = entity.state
     else:
-        value = str(entity.attributes.get(attribute))
+        value = entity.attributes.get(attribute)
 
-    if isinstance(req_state, str):
+    if not isinstance(req_state, list):
         req_state = [req_state]
 
     is_state = False
     for req_state_value in req_state:
         state_value = req_state_value
-        if INPUT_ENTITY_ID.match(req_state_value) is not None:
+        if (
+            isinstance(req_state_value, str)
+            and INPUT_ENTITY_ID.match(req_state_value) is not None
+        ):
             state_entity = hass.states.get(req_state_value)
             if not state_entity:
                 continue
diff --git a/homeassistant/helpers/config_validation.py b/homeassistant/helpers/config_validation.py
index 282e63e6440..08d23a98da6 100644
--- a/homeassistant/helpers/config_validation.py
+++ b/homeassistant/helpers/config_validation.py
@@ -929,22 +929,44 @@ NUMERIC_STATE_CONDITION_SCHEMA = vol.All(
     has_at_least_one_key(CONF_BELOW, CONF_ABOVE),
 )
 
-STATE_CONDITION_SCHEMA = vol.All(
-    vol.Schema(
-        {
-            vol.Required(CONF_CONDITION): "state",
-            vol.Required(CONF_ENTITY_ID): entity_ids,
-            vol.Optional(CONF_ATTRIBUTE): str,
-            vol.Required(CONF_STATE): vol.Any(str, [str]),
-            vol.Optional(CONF_FOR): positive_time_period,
-            # To support use_trigger_value in automation
-            # Deprecated 2016/04/25
-            vol.Optional("from"): str,
-        }
-    ),
-    key_dependency("for", "state"),
+STATE_CONDITION_BASE_SCHEMA = {
+    vol.Required(CONF_CONDITION): "state",
+    vol.Required(CONF_ENTITY_ID): entity_ids,
+    vol.Optional(CONF_ATTRIBUTE): str,
+    vol.Optional(CONF_FOR): positive_time_period,
+    # To support use_trigger_value in automation
+    # Deprecated 2016/04/25
+    vol.Optional("from"): str,
+}
+
+STATE_CONDITION_STATE_SCHEMA = vol.Schema(
+    {
+        **STATE_CONDITION_BASE_SCHEMA,
+        vol.Required(CONF_STATE): vol.Any(str, [str]),
+    }
 )
 
+STATE_CONDITION_ATTRIBUTE_SCHEMA = vol.Schema(
+    {
+        **STATE_CONDITION_BASE_SCHEMA,
+        vol.Required(CONF_STATE): match_all,
+    }
+)
+
+
+def STATE_CONDITION_SCHEMA(value: Any) -> dict:  # pylint: disable=invalid-name
+    """Validate a state condition."""
+    if not isinstance(value, dict):
+        raise vol.Invalid("Expected a dictionary")
+
+    if CONF_ATTRIBUTE in value:
+        validated: dict = STATE_CONDITION_ATTRIBUTE_SCHEMA(value)
+    else:
+        validated = STATE_CONDITION_STATE_SCHEMA(value)
+
+    return key_dependency("for", "state")(validated)
+
+
 SUN_CONDITION_SCHEMA = vol.All(
     vol.Schema(
         {
diff --git a/tests/components/homeassistant/triggers/test_state.py b/tests/components/homeassistant/triggers/test_state.py
index 688115dc400..61fa991e0f4 100644
--- a/tests/components/homeassistant/triggers/test_state.py
+++ b/tests/components/homeassistant/triggers/test_state.py
@@ -1240,3 +1240,32 @@ async def test_attribute_if_not_fires_on_entities_change_with_for_after_stop(
     async_fire_time_changed(hass, dt_util.utcnow() + timedelta(seconds=10))
     await hass.async_block_till_done()
     assert len(calls) == 1
+
+
+async def test_attribute_if_fires_on_entity_change_with_both_filters_boolean(
+    hass, calls
+):
+    """Test for firing if both filters are match attribute."""
+    hass.states.async_set("test.entity", "bla", {"happening": False})
+
+    assert await async_setup_component(
+        hass,
+        automation.DOMAIN,
+        {
+            automation.DOMAIN: {
+                "trigger": {
+                    "platform": "state",
+                    "entity_id": "test.entity",
+                    "from": False,
+                    "to": True,
+                    "attribute": "happening",
+                },
+                "action": {"service": "test.automation"},
+            }
+        },
+    )
+    await hass.async_block_till_done()
+
+    hass.states.async_set("test.entity", "bla", {"happening": True})
+    await hass.async_block_till_done()
+    assert len(calls) == 1
diff --git a/tests/helpers/test_condition.py b/tests/helpers/test_condition.py
index 71770d21186..001c59e2f2c 100644
--- a/tests/helpers/test_condition.py
+++ b/tests/helpers/test_condition.py
@@ -422,7 +422,7 @@ async def test_state_attribute(hass):
                     "condition": "state",
                     "entity_id": "sensor.temperature",
                     "attribute": "attribute1",
-                    "state": "200",
+                    "state": 200,
                 },
             ],
         },
@@ -435,7 +435,7 @@ async def test_state_attribute(hass):
     assert test(hass)
 
     hass.states.async_set("sensor.temperature", 100, {"attribute1": "200"})
-    assert test(hass)
+    assert not test(hass)
 
     hass.states.async_set("sensor.temperature", 100, {"attribute1": 201})
     assert not test(hass)
@@ -444,6 +444,31 @@ async def test_state_attribute(hass):
     assert not test(hass)
 
 
+async def test_state_attribute_boolean(hass):
+    """Test with boolean state attribute in condition."""
+    test = await condition.async_from_config(
+        hass,
+        {
+            "condition": "state",
+            "entity_id": "sensor.temperature",
+            "attribute": "happening",
+            "state": False,
+        },
+    )
+
+    hass.states.async_set("sensor.temperature", 100, {"happening": 200})
+    assert not test(hass)
+
+    hass.states.async_set("sensor.temperature", 100, {"happening": True})
+    assert not test(hass)
+
+    hass.states.async_set("sensor.temperature", 100, {"no_happening": 201})
+    assert not test(hass)
+
+    hass.states.async_set("sensor.temperature", 100, {"happening": False})
+    assert test(hass)
+
+
 async def test_state_using_input_entities(hass):
     """Test state conditions using input_* entities."""
     await async_setup_component(

From 6f4225b51d353f939e86d8faba1efb2af36ed60d Mon Sep 17 00:00:00 2001
From: Paulus Schoutsen <balloob@gmail.com>
Date: Mon, 5 Oct 2020 14:03:48 +0200
Subject: [PATCH 31/82] Add extended validation for script repeat/choose
 (#41265)

---
 homeassistant/components/automation/config.py |   6 +-
 homeassistant/helpers/script.py               |  59 +++++++--
 tests/helpers/test_script.py                  | 112 ++++++++++++++++++
 3 files changed, 164 insertions(+), 13 deletions(-)

diff --git a/homeassistant/components/automation/config.py b/homeassistant/components/automation/config.py
index 2ac2b8d9354..3a296178aeb 100644
--- a/homeassistant/components/automation/config.py
+++ b/homeassistant/components/automation/config.py
@@ -10,7 +10,7 @@ from homeassistant.config import async_log_exception, config_without_domain
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import config_per_platform
 from homeassistant.helpers.condition import async_validate_condition_config
-from homeassistant.helpers.script import async_validate_action_config
+from homeassistant.helpers.script import async_validate_actions_config
 from homeassistant.helpers.trigger import async_validate_trigger_config
 from homeassistant.loader import IntegrationNotFound
 
@@ -36,9 +36,7 @@ async def async_validate_config_item(hass, config, full_config=None):
             ]
         )
 
-    config[CONF_ACTION] = await asyncio.gather(
-        *[async_validate_action_config(hass, action) for action in config[CONF_ACTION]]
-    )
+    config[CONF_ACTION] = await async_validate_actions_config(hass, config[CONF_ACTION])
 
     return config
 
diff --git a/homeassistant/helpers/script.py b/homeassistant/helpers/script.py
index 05808d3bcd5..4d958fe431f 100644
--- a/homeassistant/helpers/script.py
+++ b/homeassistant/helpers/script.py
@@ -123,30 +123,71 @@ def make_script_schema(schema, default_script_mode, extra=vol.PREVENT_EXTRA):
     )
 
 
+STATIC_VALIDATION_ACTION_TYPES = (
+    cv.SCRIPT_ACTION_CALL_SERVICE,
+    cv.SCRIPT_ACTION_DELAY,
+    cv.SCRIPT_ACTION_WAIT_TEMPLATE,
+    cv.SCRIPT_ACTION_FIRE_EVENT,
+    cv.SCRIPT_ACTION_ACTIVATE_SCENE,
+    cv.SCRIPT_ACTION_VARIABLES,
+)
+
+
+async def async_validate_actions_config(
+    hass: HomeAssistant, actions: List[ConfigType]
+) -> List[ConfigType]:
+    """Validate a list of actions."""
+    return await asyncio.gather(
+        *[async_validate_action_config(hass, action) for action in actions]
+    )
+
+
 async def async_validate_action_config(
     hass: HomeAssistant, config: ConfigType
 ) -> ConfigType:
     """Validate config."""
     action_type = cv.determine_script_action(config)
 
-    if action_type == cv.SCRIPT_ACTION_DEVICE_AUTOMATION:
+    if action_type in STATIC_VALIDATION_ACTION_TYPES:
+        pass
+
+    elif action_type == cv.SCRIPT_ACTION_DEVICE_AUTOMATION:
         platform = await device_automation.async_get_device_automation_platform(
             hass, config[CONF_DOMAIN], "action"
         )
         config = platform.ACTION_SCHEMA(config)  # type: ignore
-    elif (
-        action_type == cv.SCRIPT_ACTION_CHECK_CONDITION
-        and config[CONF_CONDITION] == "device"
-    ):
-        platform = await device_automation.async_get_device_automation_platform(
-            hass, config[CONF_DOMAIN], "condition"
-        )
-        config = platform.CONDITION_SCHEMA(config)  # type: ignore
+
+    elif action_type == cv.SCRIPT_ACTION_CHECK_CONDITION:
+        if config[CONF_CONDITION] == "device":
+            platform = await device_automation.async_get_device_automation_platform(
+                hass, config[CONF_DOMAIN], "condition"
+            )
+            config = platform.CONDITION_SCHEMA(config)  # type: ignore
+
     elif action_type == cv.SCRIPT_ACTION_WAIT_FOR_TRIGGER:
         config[CONF_WAIT_FOR_TRIGGER] = await async_validate_trigger_config(
             hass, config[CONF_WAIT_FOR_TRIGGER]
         )
 
+    elif action_type == cv.SCRIPT_ACTION_REPEAT:
+        config[CONF_SEQUENCE] = await async_validate_actions_config(
+            hass, config[CONF_REPEAT][CONF_SEQUENCE]
+        )
+
+    elif action_type == cv.SCRIPT_ACTION_CHOOSE:
+        if CONF_DEFAULT in config:
+            config[CONF_DEFAULT] = await async_validate_actions_config(
+                hass, config[CONF_DEFAULT]
+            )
+
+        for choose_conf in config[CONF_CHOOSE]:
+            choose_conf[CONF_SEQUENCE] = await async_validate_actions_config(
+                hass, choose_conf[CONF_SEQUENCE]
+            )
+
+    else:
+        raise ValueError(f"No validation for {action_type}")
+
     return config
 
 
diff --git a/tests/helpers/test_script.py b/tests/helpers/test_script.py
index 936866b4306..93bb249c485 100644
--- a/tests/helpers/test_script.py
+++ b/tests/helpers/test_script.py
@@ -16,6 +16,7 @@ import homeassistant.components.scene as scene
 from homeassistant.const import ATTR_ENTITY_ID, SERVICE_TURN_ON
 from homeassistant.core import Context, CoreState, callback
 from homeassistant.helpers import config_validation as cv, script
+from homeassistant.setup import async_setup_component
 import homeassistant.util.dt as dt_util
 
 from tests.async_mock import patch
@@ -1828,3 +1829,114 @@ async def test_set_redefines_variable(hass, caplog):
 
     assert mock_calls[0].data["value"] == "1"
     assert mock_calls[1].data["value"] == "2"
+
+
+async def test_validate_action_config(hass):
+    """Validate action config."""
+    configs = {
+        cv.SCRIPT_ACTION_CALL_SERVICE: {"service": "light.turn_on"},
+        cv.SCRIPT_ACTION_DELAY: {"delay": 5},
+        cv.SCRIPT_ACTION_WAIT_TEMPLATE: {
+            "wait_template": "{{ states.light.kitchen.state == 'on' }}"
+        },
+        cv.SCRIPT_ACTION_FIRE_EVENT: {"event": "my_event"},
+        cv.SCRIPT_ACTION_CHECK_CONDITION: {
+            "condition": "{{ states.light.kitchen.state == 'on' }}"
+        },
+        cv.SCRIPT_ACTION_DEVICE_AUTOMATION: {
+            "domain": "light",
+            "entity_id": "light.kitchen",
+            "device_id": "abcd",
+            "type": "turn_on",
+        },
+        cv.SCRIPT_ACTION_ACTIVATE_SCENE: {"scene": "scene.relax"},
+        cv.SCRIPT_ACTION_REPEAT: {
+            "repeat": {"count": 3, "sequence": [{"event": "repeat_event"}]}
+        },
+        cv.SCRIPT_ACTION_CHOOSE: {
+            "choose": [
+                {
+                    "condition": "{{ states.light.kitchen.state == 'on' }}",
+                    "sequence": [{"event": "choose_event"}],
+                }
+            ],
+            "default": [{"event": "choose_default_event"}],
+        },
+        cv.SCRIPT_ACTION_WAIT_FOR_TRIGGER: {
+            "wait_for_trigger": [
+                {"platform": "event", "event_type": "wait_for_trigger_event"}
+            ]
+        },
+        cv.SCRIPT_ACTION_VARIABLES: {"variables": {"hello": "world"}},
+    }
+
+    for key in cv.ACTION_TYPE_SCHEMAS:
+        assert key in configs, f"No validate config test found for {key}"
+
+    # Verify we raise if we don't know the action type
+    with patch(
+        "homeassistant.helpers.config_validation.determine_script_action",
+        return_value="non-existing",
+    ), pytest.raises(ValueError):
+        await script.async_validate_action_config(hass, {})
+
+    for action_type, config in configs.items():
+        assert cv.determine_script_action(config) == action_type
+        try:
+            await script.async_validate_action_config(hass, config)
+        except vol.Invalid as err:
+            assert False, f"{action_type} config invalid: {err}"
+
+
+async def test_embedded_wait_for_trigger_in_automation(hass):
+    """Test an embedded wait for trigger."""
+    assert await async_setup_component(
+        hass,
+        "automation",
+        {
+            "automation": {
+                "trigger": {"platform": "event", "event_type": "test_event"},
+                "action": {
+                    "repeat": {
+                        "while": [
+                            {
+                                "condition": "template",
+                                "value_template": '{{ is_state("test.value1", "trigger-while") }}',
+                            }
+                        ],
+                        "sequence": [
+                            {"event": "trigger_wait_event"},
+                            {
+                                "wait_for_trigger": [
+                                    {
+                                        "platform": "template",
+                                        "value_template": '{{ is_state("test.value2", "trigger-wait") }}',
+                                    }
+                                ]
+                            },
+                            {"service": "test.script"},
+                        ],
+                    }
+                },
+            }
+        },
+    )
+
+    hass.states.async_set("test.value1", "trigger-while")
+    hass.states.async_set("test.value2", "not-trigger-wait")
+    mock_calls = async_mock_service(hass, "test", "script")
+
+    async def trigger_wait_event(_):
+        # give script the time to attach the trigger.
+        await asyncio.sleep(0)
+        hass.states.async_set("test.value1", "not-trigger-while")
+        hass.states.async_set("test.value2", "trigger-wait")
+
+    hass.bus.async_listen("trigger_wait_event", trigger_wait_event)
+
+    # Start automation
+    hass.bus.async_fire("test_event")
+
+    await hass.async_block_till_done()
+
+    assert len(mock_calls) == 1

From 74b5db9ca5953d8542bdc9ceabdef68dc0adefb3 Mon Sep 17 00:00:00 2001
From: Paulus Schoutsen <balloob@gmail.com>
Date: Mon, 5 Oct 2020 12:05:54 +0000
Subject: [PATCH 32/82] Bumped version to 0.116.0b3

---
 homeassistant/const.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/homeassistant/const.py b/homeassistant/const.py
index bfad4f9d766..c63395817f0 100644
--- a/homeassistant/const.py
+++ b/homeassistant/const.py
@@ -1,7 +1,7 @@
 """Constants used by Home Assistant components."""
 MAJOR_VERSION = 0
 MINOR_VERSION = 116
-PATCH_VERSION = "0b2"
+PATCH_VERSION = "0b3"
 __short_version__ = f"{MAJOR_VERSION}.{MINOR_VERSION}"
 __version__ = f"{__short_version__}.{PATCH_VERSION}"
 REQUIRED_PYTHON_VER = (3, 7, 1)

From df371d99dc79ce1a602763a21c99dd7e131de1ba Mon Sep 17 00:00:00 2001
From: Bram Kragten <mail@bramkragten.nl>
Date: Mon, 5 Oct 2020 17:39:13 +0200
Subject: [PATCH 33/82] Updated frontend to 20201001.1 (#41273)

---
 homeassistant/components/frontend/manifest.json | 2 +-
 homeassistant/package_constraints.txt           | 2 +-
 requirements_all.txt                            | 2 +-
 requirements_test_all.txt                       | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/homeassistant/components/frontend/manifest.json b/homeassistant/components/frontend/manifest.json
index f6a2e4db0d8..6732f6e99c3 100644
--- a/homeassistant/components/frontend/manifest.json
+++ b/homeassistant/components/frontend/manifest.json
@@ -2,7 +2,7 @@
   "domain": "frontend",
   "name": "Home Assistant Frontend",
   "documentation": "https://www.home-assistant.io/integrations/frontend",
-  "requirements": ["home-assistant-frontend==20201001.0"],
+  "requirements": ["home-assistant-frontend==20201001.1"],
   "dependencies": [
     "api",
     "auth",
diff --git a/homeassistant/package_constraints.txt b/homeassistant/package_constraints.txt
index 6d3a9101c75..cdda546a4e1 100644
--- a/homeassistant/package_constraints.txt
+++ b/homeassistant/package_constraints.txt
@@ -13,7 +13,7 @@ defusedxml==0.6.0
 distro==1.5.0
 emoji==0.5.4
 hass-nabucasa==0.37.0
-home-assistant-frontend==20201001.0
+home-assistant-frontend==20201001.1
 importlib-metadata==1.6.0;python_version<'3.8'
 jinja2>=2.11.2
 netdisco==2.8.2
diff --git a/requirements_all.txt b/requirements_all.txt
index b9f69e7c1ce..35d6b2b75de 100644
--- a/requirements_all.txt
+++ b/requirements_all.txt
@@ -753,7 +753,7 @@ hole==0.5.1
 holidays==0.10.3
 
 # homeassistant.components.frontend
-home-assistant-frontend==20201001.0
+home-assistant-frontend==20201001.1
 
 # homeassistant.components.zwave
 homeassistant-pyozw==0.1.10
diff --git a/requirements_test_all.txt b/requirements_test_all.txt
index b597d0997af..141284388ba 100644
--- a/requirements_test_all.txt
+++ b/requirements_test_all.txt
@@ -376,7 +376,7 @@ hole==0.5.1
 holidays==0.10.3
 
 # homeassistant.components.frontend
-home-assistant-frontend==20201001.0
+home-assistant-frontend==20201001.1
 
 # homeassistant.components.zwave
 homeassistant-pyozw==0.1.10

From 56b5ddb06d2c0854d4a4890865885b43523e003c Mon Sep 17 00:00:00 2001
From: Bram Kragten <mail@bramkragten.nl>
Date: Mon, 5 Oct 2020 18:05:31 +0200
Subject: [PATCH 34/82] Bumped version to 0.116.0b4

---
 homeassistant/const.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/homeassistant/const.py b/homeassistant/const.py
index c63395817f0..d89efa8ebce 100644
--- a/homeassistant/const.py
+++ b/homeassistant/const.py
@@ -1,7 +1,7 @@
 """Constants used by Home Assistant components."""
 MAJOR_VERSION = 0
 MINOR_VERSION = 116
-PATCH_VERSION = "0b3"
+PATCH_VERSION = "0b4"
 __short_version__ = f"{MAJOR_VERSION}.{MINOR_VERSION}"
 __version__ = f"{__short_version__}.{PATCH_VERSION}"
 REQUIRED_PYTHON_VER = (3, 7, 1)

From 874cbf808e905362d4829b721140bb8a6fe9b6bb Mon Sep 17 00:00:00 2001
From: Andrew Sayre <6730289+andrewsayre@users.noreply.github.com>
Date: Mon, 5 Oct 2020 15:12:38 -0500
Subject: [PATCH 35/82] Update pysmartthings (#41294)

---
 homeassistant/components/smartthings/manifest.json | 2 +-
 requirements_all.txt                               | 2 +-
 requirements_test_all.txt                          | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/homeassistant/components/smartthings/manifest.json b/homeassistant/components/smartthings/manifest.json
index 58ea833cb7d..30ef278d1d1 100644
--- a/homeassistant/components/smartthings/manifest.json
+++ b/homeassistant/components/smartthings/manifest.json
@@ -3,7 +3,7 @@
   "name": "SmartThings",
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/smartthings",
-  "requirements": ["pysmartapp==0.3.2", "pysmartthings==0.7.3"],
+  "requirements": ["pysmartapp==0.3.2", "pysmartthings==0.7.4"],
   "dependencies": ["webhook"],
   "after_dependencies": ["cloud"],
   "codeowners": ["@andrewsayre"]
diff --git a/requirements_all.txt b/requirements_all.txt
index 35d6b2b75de..58302505469 100644
--- a/requirements_all.txt
+++ b/requirements_all.txt
@@ -1653,7 +1653,7 @@ pysmappee==0.2.13
 pysmartapp==0.3.2
 
 # homeassistant.components.smartthings
-pysmartthings==0.7.3
+pysmartthings==0.7.4
 
 # homeassistant.components.smarty
 pysmarty==0.8
diff --git a/requirements_test_all.txt b/requirements_test_all.txt
index 141284388ba..2454f3e9438 100644
--- a/requirements_test_all.txt
+++ b/requirements_test_all.txt
@@ -800,7 +800,7 @@ pysmappee==0.2.13
 pysmartapp==0.3.2
 
 # homeassistant.components.smartthings
-pysmartthings==0.7.3
+pysmartthings==0.7.4
 
 # homeassistant.components.soma
 pysoma==0.0.10

From 859632d63670d7f7e3015c489f47c29cdc207061 Mon Sep 17 00:00:00 2001
From: Bram Kragten <mail@bramkragten.nl>
Date: Mon, 5 Oct 2020 22:09:47 +0200
Subject: [PATCH 36/82] Exclude media_dirs from YAML config check (#41299)

---
 homeassistant/config.py |  1 -
 tests/test_config.py    | 30 ++++++++++++++++++++++++++++++
 2 files changed, 30 insertions(+), 1 deletion(-)

diff --git a/homeassistant/config.py b/homeassistant/config.py
index 8f9dc7c3d62..3e9dd27458d 100644
--- a/homeassistant/config.py
+++ b/homeassistant/config.py
@@ -488,7 +488,6 @@ async def async_process_ha_core_config(hass: HomeAssistant, config: Dict) -> Non
             CONF_UNIT_SYSTEM,
             CONF_EXTERNAL_URL,
             CONF_INTERNAL_URL,
-            CONF_MEDIA_DIRS,
         ]
     ):
         hac.config_source = SOURCE_YAML
diff --git a/tests/test_config.py b/tests/test_config.py
index fb22ee1118e..181e80da30c 100644
--- a/tests/test_config.py
+++ b/tests/test_config.py
@@ -369,6 +369,36 @@ async def test_loading_configuration_from_storage(hass, hass_storage):
     assert hass.config.config_source == SOURCE_STORAGE
 
 
+async def test_loading_configuration_from_storage_with_yaml_only(hass, hass_storage):
+    """Test loading core and YAML config onto hass object."""
+    hass_storage["core.config"] = {
+        "data": {
+            "elevation": 10,
+            "latitude": 55,
+            "location_name": "Home",
+            "longitude": 13,
+            "time_zone": "Europe/Copenhagen",
+            "unit_system": "metric",
+        },
+        "key": "core.config",
+        "version": 1,
+    }
+    await config_util.async_process_ha_core_config(
+        hass, {"media_dirs": {"mymedia": "/usr"}, "allowlist_external_dirs": "/etc"}
+    )
+
+    assert hass.config.latitude == 55
+    assert hass.config.longitude == 13
+    assert hass.config.elevation == 10
+    assert hass.config.location_name == "Home"
+    assert hass.config.units.name == CONF_UNIT_SYSTEM_METRIC
+    assert hass.config.time_zone.zone == "Europe/Copenhagen"
+    assert len(hass.config.allowlist_external_dirs) == 3
+    assert "/etc" in hass.config.allowlist_external_dirs
+    assert hass.config.media_dirs == {"mymedia": "/usr"}
+    assert hass.config.config_source == SOURCE_STORAGE
+
+
 async def test_updating_configuration(hass, hass_storage):
     """Test updating configuration stores the new configuration."""
     core_data = {

From 23be039b7f8f8fabd9716c5fef40cfa81047a7a8 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Tue, 6 Oct 2020 00:25:05 -0500
Subject: [PATCH 37/82] Prevent collecting states already referenced by domain
 or all (#41308)

The template engine would collect all the states in
a domain or all states while iterating even though
they were already included in all or the domain

This lead to the rate limit not being applied to
templates that iterated all states that also
accessed a collectable property because the engine
incorrectly believed they were specifically
referenced.
---
 homeassistant/helpers/template.py | 11 +++--
 tests/helpers/test_event.py       | 76 +++++++++++++++++++++++++++++-
 tests/helpers/test_template.py    | 77 ++++++++++++++-----------------
 3 files changed, 115 insertions(+), 49 deletions(-)

diff --git a/homeassistant/helpers/template.py b/homeassistant/helpers/template.py
index c0ceb17fdd7..9c849bee22e 100644
--- a/homeassistant/helpers/template.py
+++ b/homeassistant/helpers/template.py
@@ -587,17 +587,18 @@ class DomainStates:
 class TemplateState(State):
     """Class to represent a state object in a template."""
 
-    __slots__ = ("_hass", "_state")
+    __slots__ = ("_hass", "_state", "_collect")
 
     # Inheritance is done so functions that check against State keep working
     # pylint: disable=super-init-not-called
-    def __init__(self, hass, state):
+    def __init__(self, hass, state, collect=True):
         """Initialize template state."""
         self._hass = hass
         self._state = state
+        self._collect = collect
 
     def _collect_state(self):
-        if _RENDER_INFO in self._hass.data:
+        if self._collect and _RENDER_INFO in self._hass.data:
             self._hass.data[_RENDER_INFO].entities.add(self._state.entity_id)
 
     # Jinja will try __getitem__ first and it avoids the need
@@ -606,7 +607,7 @@ class TemplateState(State):
         """Return a property as an attribute for jinja."""
         if item in _COLLECTABLE_STATE_ATTRIBUTES:
             # _collect_state inlined here for performance
-            if _RENDER_INFO in self._hass.data:
+            if self._collect and _RENDER_INFO in self._hass.data:
                 self._hass.data[_RENDER_INFO].entities.add(self._state.entity_id)
             return getattr(self._state, item)
         if item == "entity_id":
@@ -697,7 +698,7 @@ def _collect_state(hass: HomeAssistantType, entity_id: str) -> None:
 def _state_generator(hass: HomeAssistantType, domain: Optional[str]) -> Generator:
     """State generator for a domain or all states."""
     for state in sorted(hass.states.async_all(domain), key=attrgetter("entity_id")):
-        yield TemplateState(hass, state)
+        yield TemplateState(hass, state, collect=False)
 
 
 def _get_state_if_valid(
diff --git a/tests/helpers/test_event.py b/tests/helpers/test_event.py
index bf0efaf8cf6..bb0d17d7b0e 100644
--- a/tests/helpers/test_event.py
+++ b/tests/helpers/test_event.py
@@ -1284,7 +1284,7 @@ async def test_track_template_result_iterator(hass):
     assert info.listeners == {
         "all": False,
         "domains": {"sensor"},
-        "entities": {"sensor.test"},
+        "entities": set(),
     }
 
     hass.states.async_set("sensor.test", 6)
@@ -1488,6 +1488,80 @@ async def test_track_template_rate_limit_five(hass):
     assert refresh_runs == ["0", "1"]
 
 
+async def test_track_template_has_default_rate_limit(hass):
+    """Test template has a rate limit by default."""
+    hass.states.async_set("sensor.zero", "any")
+    template_refresh = Template("{{ states | list | count }}", hass)
+
+    refresh_runs = []
+
+    @ha.callback
+    def refresh_listener(event, updates):
+        refresh_runs.append(updates.pop().result)
+
+    info = async_track_template_result(
+        hass,
+        [TrackTemplate(template_refresh, None)],
+        refresh_listener,
+    )
+    await hass.async_block_till_done()
+    info.async_refresh()
+    await hass.async_block_till_done()
+
+    assert refresh_runs == ["1"]
+    hass.states.async_set("sensor.one", "any")
+    await hass.async_block_till_done()
+    assert refresh_runs == ["1"]
+    info.async_refresh()
+    assert refresh_runs == ["1", "2"]
+    hass.states.async_set("sensor.two", "any")
+    await hass.async_block_till_done()
+    assert refresh_runs == ["1", "2"]
+    hass.states.async_set("sensor.three", "any")
+    await hass.async_block_till_done()
+    assert refresh_runs == ["1", "2"]
+
+
+async def test_track_template_unavailable_sates_has_default_rate_limit(hass):
+    """Test template watching for unavailable states has a rate limit by default."""
+    hass.states.async_set("sensor.zero", "unknown")
+    template_refresh = Template(
+        "{{ states | selectattr('state', 'in', ['unavailable', 'unknown', 'none']) | list | count }}",
+        hass,
+    )
+
+    refresh_runs = []
+
+    @ha.callback
+    def refresh_listener(event, updates):
+        refresh_runs.append(updates.pop().result)
+
+    info = async_track_template_result(
+        hass,
+        [TrackTemplate(template_refresh, None)],
+        refresh_listener,
+    )
+    await hass.async_block_till_done()
+    info.async_refresh()
+    await hass.async_block_till_done()
+
+    assert refresh_runs == ["1"]
+    hass.states.async_set("sensor.one", "unknown")
+    await hass.async_block_till_done()
+    assert refresh_runs == ["1"]
+    info.async_refresh()
+    assert refresh_runs == ["1", "2"]
+    hass.states.async_set("sensor.two", "any")
+    await hass.async_block_till_done()
+    assert refresh_runs == ["1", "2"]
+    hass.states.async_set("sensor.three", "unknown")
+    await hass.async_block_till_done()
+    assert refresh_runs == ["1", "2"]
+    info.async_refresh()
+    await hass.async_block_till_done()
+    assert refresh_runs == ["1", "2", "3"]
+
+
 async def test_specifically_referenced_entity_is_not_rate_limited(hass):
     """Test template rate limit of 5 seconds."""
     hass.states.async_set("sensor.one", "none")
diff --git a/tests/helpers/test_template.py b/tests/helpers/test_template.py
index 7d39675bdc0..5535fa53993 100644
--- a/tests/helpers/test_template.py
+++ b/tests/helpers/test_template.py
@@ -155,9 +155,25 @@ def test_iterating_all_states(hass):
     hass.states.async_set("sensor.temperature", 10)
 
     info = render_to_info(hass, tmpl_str)
-    assert_result_info(
-        info, "10happy", entities=["test.object", "sensor.temperature"], all_states=True
-    )
+    assert_result_info(info, "10happy", entities=[], all_states=True)
+
+
+def test_iterating_all_states_unavailable(hass):
+    """Test iterating all states unavailable."""
+    hass.states.async_set("test.object", "on")
+
+    tmpl_str = "{{ states | selectattr('state', 'in', ['unavailable', 'unknown', 'none']) | list | count }}"
+
+    info = render_to_info(hass, tmpl_str)
+
+    assert info.all_states is True
+    assert info.rate_limit == template.DEFAULT_RATE_LIMIT
+
+    hass.states.async_set("test.object", "unknown")
+    hass.states.async_set("sensor.temperature", 10)
+
+    info = render_to_info(hass, tmpl_str)
+    assert_result_info(info, "1", entities=[], all_states=True)
 
 
 def test_iterating_domain_states(hass):
@@ -176,7 +192,7 @@ def test_iterating_domain_states(hass):
     assert_result_info(
         info,
         "open10",
-        entities=["sensor.back_door", "sensor.temperature"],
+        entities=[],
         domains=["sensor"],
     )
 
@@ -1426,9 +1442,7 @@ async def test_expand(hass):
     info = render_to_info(
         hass, "{{ expand(states.group) | map(attribute='entity_id') | join(', ') }}"
     )
-    assert_result_info(
-        info, "test.object", {"test.object", "group.new_group"}, ["group"]
-    )
+    assert_result_info(info, "test.object", {"test.object"}, ["group"])
     assert info.rate_limit == template.DEFAULT_RATE_LIMIT
 
     info = render_to_info(
@@ -1587,7 +1601,7 @@ async def test_async_render_to_info_with_wildcard_matching_entity_id(hass):
     """Test tracking template with a wildcard."""
     template_complex_str = r"""
 
-{% for state in states %}
+{% for state in states.cover %}
   {% if state.entity_id | regex_match('.*\.office_') %}
     {{ state.entity_id }}={{ state.state }}
   {% endif %}
@@ -1599,13 +1613,9 @@ async def test_async_render_to_info_with_wildcard_matching_entity_id(hass):
     hass.states.async_set("cover.office_skylight", "open")
     info = render_to_info(hass, template_complex_str)
 
-    assert not info.domains
-    assert info.entities == {
-        "cover.office_drapes",
-        "cover.office_window",
-        "cover.office_skylight",
-    }
-    assert info.all_states is True
+    assert info.domains == {"cover"}
+    assert info.entities == set()
+    assert info.all_states is False
     assert info.rate_limit == template.DEFAULT_RATE_LIMIT
 
 
@@ -1629,13 +1639,7 @@ async def test_async_render_to_info_with_wildcard_matching_state(hass):
     info = render_to_info(hass, template_complex_str)
 
     assert not info.domains
-    assert info.entities == {
-        "cover.x_skylight",
-        "binary_sensor.door",
-        "cover.office_drapes",
-        "cover.office_window",
-        "cover.office_skylight",
-    }
+    assert info.entities == set()
     assert info.all_states is True
     assert info.rate_limit == template.DEFAULT_RATE_LIMIT
 
@@ -1643,13 +1647,7 @@ async def test_async_render_to_info_with_wildcard_matching_state(hass):
     info = render_to_info(hass, template_complex_str)
 
     assert not info.domains
-    assert info.entities == {
-        "cover.x_skylight",
-        "binary_sensor.door",
-        "cover.office_drapes",
-        "cover.office_window",
-        "cover.office_skylight",
-    }
+    assert info.entities == set()
     assert info.all_states is True
     assert info.rate_limit == template.DEFAULT_RATE_LIMIT
 
@@ -1666,12 +1664,7 @@ async def test_async_render_to_info_with_wildcard_matching_state(hass):
     info = render_to_info(hass, template_cover_str)
 
     assert info.domains == {"cover"}
-    assert info.entities == {
-        "cover.x_skylight",
-        "cover.office_drapes",
-        "cover.office_window",
-        "cover.office_skylight",
-    }
+    assert info.entities == set()
     assert info.all_states is False
     assert info.rate_limit == template.DEFAULT_RATE_LIMIT
 
@@ -1965,9 +1958,7 @@ def test_generate_filter_iterators(hass):
         {% endfor %}
         """,
     )
-    assert_result_info(
-        info, "sensor.test_sensor=off,", ["sensor.test_sensor"], ["sensor"]
-    )
+    assert_result_info(info, "sensor.test_sensor=off,", [], ["sensor"])
 
     info = render_to_info(
         hass,
@@ -1977,9 +1968,7 @@ def test_generate_filter_iterators(hass):
         {% endfor %}
         """,
     )
-    assert_result_info(
-        info, "sensor.test_sensor=value,", ["sensor.test_sensor"], ["sensor"]
-    )
+    assert_result_info(info, "sensor.test_sensor=value,", [], ["sensor"])
 
 
 def test_generate_select(hass):
@@ -2001,7 +1990,7 @@ def test_generate_select(hass):
     assert_result_info(
         info,
         "sensor.test_sensor",
-        ["sensor.test_sensor", "sensor.test_sensor_on"],
+        [],
         ["sensor"],
     )
     assert info.domains_lifecycle == {"sensor"}
@@ -2542,7 +2531,9 @@ async def test_lights(hass):
 
     tmp = template.Template(tmpl, hass)
     info = tmp.async_render_to_info()
-    assert info.entities == set(states)
+    assert info.entities == set()
+    assert info.domains == {"light"}
+
     assert "lights are on" in info.result()
     for i in range(10):
         assert f"sensor{i}" in info.result()

From 570d1e7d8fe860ebfe34137d6efa2004e1ae869c Mon Sep 17 00:00:00 2001
From: Paulus Schoutsen <balloob@gmail.com>
Date: Tue, 6 Oct 2020 07:55:25 +0000
Subject: [PATCH 38/82] Bumped version to 0.116.0b5

---
 homeassistant/const.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/homeassistant/const.py b/homeassistant/const.py
index d89efa8ebce..833f35a2abb 100644
--- a/homeassistant/const.py
+++ b/homeassistant/const.py
@@ -1,7 +1,7 @@
 """Constants used by Home Assistant components."""
 MAJOR_VERSION = 0
 MINOR_VERSION = 116
-PATCH_VERSION = "0b4"
+PATCH_VERSION = "0b5"
 __short_version__ = f"{MAJOR_VERSION}.{MINOR_VERSION}"
 __version__ = f"{__short_version__}.{PATCH_VERSION}"
 REQUIRED_PYTHON_VER = (3, 7, 1)

From 3c22834751b80d3fdf2b8d685c7964ce9edcaa3d Mon Sep 17 00:00:00 2001
From: Steven Looman <steven.looman@gmail.com>
Date: Tue, 6 Oct 2020 13:57:36 +0200
Subject: [PATCH 39/82] Don't set upnp config_entry.unique_id from setup entry
 (#40988)

* Don't set config_entry.unique_id from setup entry. Fixes #40168

* Ensure entry has a unique_id

* Add test test_flow_import_incomplete

* Add test test_flow_import_duplicate

* Re-add testing import_info

* Simplify import flow

* Remove not needed line

Co-authored-by: Martin Hjelmare <marhje52@gmail.com>
---
 homeassistant/components/upnp/__init__.py    | 12 ++--
 homeassistant/components/upnp/config_flow.py | 32 ++++-----
 tests/components/upnp/test_config_flow.py    | 70 ++++++++++++++++++--
 3 files changed, 87 insertions(+), 27 deletions(-)

diff --git a/homeassistant/components/upnp/__init__.py b/homeassistant/components/upnp/__init__.py
index 52cada89333..773a872f33f 100644
--- a/homeassistant/components/upnp/__init__.py
+++ b/homeassistant/components/upnp/__init__.py
@@ -56,7 +56,9 @@ async def async_discover_and_construct(
             filtered = [di for di in discovery_infos if di[DISCOVERY_ST] == st]
         if not filtered:
             _LOGGER.warning(
-                'Wanted UPnP/IGD device with UDN "%s" not found, aborting', udn
+                'Wanted UPnP/IGD device with UDN/ST "%s"/"%s" not found, aborting',
+                udn,
+                st,
             )
             return None
 
@@ -104,7 +106,7 @@ async def async_setup_entry(hass: HomeAssistantType, config_entry: ConfigEntry)
     """Set up UPnP/IGD device from a config entry."""
     _LOGGER.debug("async_setup_entry, config_entry: %s", config_entry.data)
 
-    # discover and construct
+    # Discover and construct.
     udn = config_entry.data.get(CONFIG_ENTRY_UDN)
     st = config_entry.data.get(CONFIG_ENTRY_ST)  # pylint: disable=invalid-name
     try:
@@ -116,11 +118,11 @@ async def async_setup_entry(hass: HomeAssistantType, config_entry: ConfigEntry)
         _LOGGER.info("Unable to create UPnP/IGD, aborting")
         raise ConfigEntryNotReady
 
-    # Save device
+    # Save device.
     hass.data[DOMAIN][DOMAIN_DEVICES][device.udn] = device
 
-    # Ensure entry has proper unique_id.
-    if config_entry.unique_id != device.unique_id:
+    # Ensure entry has a unique_id.
+    if not config_entry.unique_id:
         hass.config_entries.async_update_entry(
             entry=config_entry,
             unique_id=device.unique_id,
diff --git a/homeassistant/components/upnp/config_flow.py b/homeassistant/components/upnp/config_flow.py
index 016a5a25017..e7c16ef0df9 100644
--- a/homeassistant/components/upnp/config_flow.py
+++ b/homeassistant/components/upnp/config_flow.py
@@ -104,19 +104,10 @@ class UpnpFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
         """
         _LOGGER.debug("async_step_import: import_info: %s", import_info)
 
-        if import_info is None:
-            # Landed here via configuration.yaml entry.
-            # Any device already added, then abort.
-            if self._async_current_entries():
-                _LOGGER.debug("aborting, already configured")
-                return self.async_abort(reason="already_configured")
-
-        # Test if import_info isn't already configured.
-        if import_info is not None and any(
-            import_info["udn"] == entry.data[CONFIG_ENTRY_UDN]
-            and import_info["st"] == entry.data[CONFIG_ENTRY_ST]
-            for entry in self._async_current_entries()
-        ):
+        # Landed here via configuration.yaml entry.
+        # Any device already added, then abort.
+        if self._async_current_entries():
+            _LOGGER.debug("Already configured, aborting")
             return self.async_abort(reason="already_configured")
 
         # Discover devices.
@@ -127,8 +118,17 @@ class UpnpFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
             _LOGGER.info("No UPnP devices discovered, aborting")
             return self.async_abort(reason="no_devices_found")
 
-        discovery = self._discoveries[0]
-        return await self._async_create_entry_from_discovery(discovery)
+        # Ensure complete discovery.
+        discovery_info = self._discoveries[0]
+        if DISCOVERY_USN not in discovery_info:
+            _LOGGER.debug("Incomplete discovery, ignoring")
+            return self.async_abort(reason="incomplete_discovery")
+
+        # Ensure not already configuring/configured.
+        usn = discovery_info[DISCOVERY_USN]
+        await self.async_set_unique_id(usn)
+
+        return await self._async_create_entry_from_discovery(discovery_info)
 
     async def async_step_ssdp(self, discovery_info: Mapping):
         """Handle a discovered UPnP/IGD device.
@@ -191,7 +191,7 @@ class UpnpFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
     ):
         """Create an entry from discovery."""
         _LOGGER.debug(
-            "_async_create_entry_from_data: discovery: %s",
+            "_async_create_entry_from_discovery: discovery: %s",
             discovery,
         )
         # Get name from device, if not found already.
diff --git a/tests/components/upnp/test_config_flow.py b/tests/components/upnp/test_config_flow.py
index 98df710d8fe..997811a835f 100644
--- a/tests/components/upnp/test_config_flow.py
+++ b/tests/components/upnp/test_config_flow.py
@@ -98,10 +98,9 @@ async def test_flow_user(hass: HomeAssistantType):
     """Test config flow: discovered + configured through user."""
     udn = "uuid:device_1"
     mock_device = MockDevice(udn)
-    usn = f"{mock_device.udn}::{mock_device.device_type}"
     discovery_infos = [
         {
-            DISCOVERY_USN: usn,
+            DISCOVERY_USN: mock_device.unique_id,
             DISCOVERY_ST: mock_device.device_type,
             DISCOVERY_UDN: mock_device.udn,
             DISCOVERY_LOCATION: "dummy",
@@ -121,7 +120,7 @@ async def test_flow_user(hass: HomeAssistantType):
         # Confirmed via step user.
         result = await hass.config_entries.flow.async_configure(
             result["flow_id"],
-            user_input={"usn": usn},
+            user_input={"usn": mock_device.unique_id},
         )
 
         assert result["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
@@ -132,14 +131,13 @@ async def test_flow_user(hass: HomeAssistantType):
         }
 
 
-async def test_flow_config(hass: HomeAssistantType):
+async def test_flow_import(hass: HomeAssistantType):
     """Test config flow: discovered + configured through configuration.yaml."""
     udn = "uuid:device_1"
     mock_device = MockDevice(udn)
-    usn = f"{mock_device.udn}::{mock_device.device_type}"
     discovery_infos = [
         {
-            DISCOVERY_USN: usn,
+            DISCOVERY_USN: mock_device.unique_id,
             DISCOVERY_ST: mock_device.device_type,
             DISCOVERY_UDN: mock_device.udn,
             DISCOVERY_LOCATION: "dummy",
@@ -162,6 +160,66 @@ async def test_flow_config(hass: HomeAssistantType):
         }
 
 
+async def test_flow_import_duplicate(hass: HomeAssistantType):
+    """Test config flow: discovered, but already configured."""
+    udn = "uuid:device_1"
+    mock_device = MockDevice(udn)
+    discovery_infos = [
+        {
+            DISCOVERY_USN: mock_device.unique_id,
+            DISCOVERY_ST: mock_device.device_type,
+            DISCOVERY_UDN: mock_device.udn,
+            DISCOVERY_LOCATION: "dummy",
+        }
+    ]
+
+    # Existing entry.
+    config_entry = MockConfigEntry(
+        domain=DOMAIN,
+        data={
+            CONFIG_ENTRY_UDN: mock_device.udn,
+            CONFIG_ENTRY_ST: mock_device.device_type,
+        },
+        options={CONFIG_ENTRY_SCAN_INTERVAL: DEFAULT_SCAN_INTERVAL},
+    )
+    config_entry.add_to_hass(hass)
+
+    with patch.object(
+        Device, "async_create_device", AsyncMock(return_value=mock_device)
+    ), patch.object(Device, "async_discover", AsyncMock(return_value=discovery_infos)):
+        # Discovered via step import.
+        result = await hass.config_entries.flow.async_init(
+            DOMAIN, context={"source": config_entries.SOURCE_IMPORT}
+        )
+
+        assert result["type"] == data_entry_flow.RESULT_TYPE_ABORT
+        assert result["reason"] == "already_configured"
+
+
+async def test_flow_import_incomplete(hass: HomeAssistantType):
+    """Test config flow: incomplete discovery, configured through configuration.yaml."""
+    udn = "uuid:device_1"
+    mock_device = MockDevice(udn)
+    discovery_infos = [
+        {
+            DISCOVERY_ST: mock_device.device_type,
+            DISCOVERY_UDN: mock_device.udn,
+            DISCOVERY_LOCATION: "dummy",
+        }
+    ]
+
+    with patch.object(
+        Device, "async_create_device", AsyncMock(return_value=mock_device)
+    ), patch.object(Device, "async_discover", AsyncMock(return_value=discovery_infos)):
+        # Discovered via step import.
+        result = await hass.config_entries.flow.async_init(
+            DOMAIN, context={"source": config_entries.SOURCE_IMPORT}
+        )
+
+        assert result["type"] == data_entry_flow.RESULT_TYPE_ABORT
+        assert result["reason"] == "incomplete_discovery"
+
+
 async def test_options_flow(hass: HomeAssistantType):
     """Test options flow."""
     # Set up config entry.

From 0470142701672e528bc3364527f943009df827af Mon Sep 17 00:00:00 2001
From: Franck Nijhof <git@frenck.dev>
Date: Tue, 6 Oct 2020 17:49:14 +0200
Subject: [PATCH 40/82] Fix TTS ID3 Tag capability check (#41343)

---
 homeassistant/components/tts/__init__.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/homeassistant/components/tts/__init__.py b/homeassistant/components/tts/__init__.py
index e8e07092ce5..7ee4922677c 100644
--- a/homeassistant/components/tts/__init__.py
+++ b/homeassistant/components/tts/__init__.py
@@ -11,7 +11,7 @@ from typing import Dict, Optional
 
 from aiohttp import web
 import mutagen
-from mutagen.id3 import ID3, TextFrame as ID3Text
+from mutagen.id3 import ID3FileType, TextFrame as ID3Text
 import voluptuous as vol
 
 from homeassistant.components.http import HomeAssistantView
@@ -468,7 +468,7 @@ class SpeechManager:
         try:
             tts_file = mutagen.File(data_bytes)
             if tts_file is not None:
-                if isinstance(tts_file.tags, ID3):
+                if isinstance(tts_file, ID3FileType):
                     tts_file["artist"] = ID3Text(encoding=3, text=artist)
                     tts_file["album"] = ID3Text(encoding=3, text=album)
                     tts_file["title"] = ID3Text(encoding=3, text=message)

From a11fa832ef022afb12b6d7cf65cef16334e5bcd4 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Tue, 6 Oct 2020 13:12:47 -0500
Subject: [PATCH 41/82] Resolve memory leak in recorder (#41349)

Avoids a build up of the InstanceState.
---
 homeassistant/components/recorder/__init__.py | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/homeassistant/components/recorder/__init__.py b/homeassistant/components/recorder/__init__.py
index 02a07bab628..63d466fa4d1 100644
--- a/homeassistant/components/recorder/__init__.py
+++ b/homeassistant/components/recorder/__init__.py
@@ -240,6 +240,7 @@ class Recorder(threading.Thread):
         self._timechanges_seen = 0
         self._keepalive_count = 0
         self._old_states = {}
+        self._pending_expunge = []
         self.event_session = None
         self.get_session = None
         self._completed_database_setup = False
@@ -403,6 +404,7 @@ class Recorder(threading.Thread):
                     self.event_session.add(dbstate)
                     if has_new_state:
                         self._old_states[dbstate.entity_id] = dbstate
+                        self._pending_expunge.append(dbstate)
                 except (TypeError, ValueError):
                     _LOGGER.warning(
                         "State is not JSON serializable: %s",
@@ -488,6 +490,12 @@ class Recorder(threading.Thread):
 
     def _commit_event_session(self):
         try:
+            self.event_session.flush()
+            for dbstate in self._pending_expunge:
+                # Expunge the state so its not expired
+                # until we use it later for dbstate.old_state
+                self.event_session.expunge(dbstate)
+            self._pending_expunge = []
             self.event_session.commit()
         except Exception as err:
             _LOGGER.error("Error executing query: %s", err)
@@ -573,9 +581,7 @@ class Recorder(threading.Thread):
         sqlalchemy_event.listen(self.engine, "connect", setup_recorder_connection)
 
         Base.metadata.create_all(self.engine)
-        self.get_session = scoped_session(
-            sessionmaker(bind=self.engine, expire_on_commit=False)
-        )
+        self.get_session = scoped_session(sessionmaker(bind=self.engine))
 
     def _close_connection(self):
         """Close the connection."""

From aefa305f77c2e94a0da9104449058a02632056ab Mon Sep 17 00:00:00 2001
From: Paulus Schoutsen <balloob@gmail.com>
Date: Tue, 6 Oct 2020 20:46:27 +0000
Subject: [PATCH 42/82] Bumped version to 0.116.0b6

---
 homeassistant/const.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/homeassistant/const.py b/homeassistant/const.py
index 833f35a2abb..c4f6f1c6879 100644
--- a/homeassistant/const.py
+++ b/homeassistant/const.py
@@ -1,7 +1,7 @@
 """Constants used by Home Assistant components."""
 MAJOR_VERSION = 0
 MINOR_VERSION = 116
-PATCH_VERSION = "0b5"
+PATCH_VERSION = "0b6"
 __short_version__ = f"{MAJOR_VERSION}.{MINOR_VERSION}"
 __version__ = f"{__short_version__}.{PATCH_VERSION}"
 REQUIRED_PYTHON_VER = (3, 7, 1)

From 281456b252f893f630414098e483ec828aabc1ca Mon Sep 17 00:00:00 2001
From: Quentame <polletquentin74@me.com>
Date: Wed, 7 Oct 2020 01:14:05 +0200
Subject: [PATCH 43/82] Set longer timeout during synology_dsm config flow
 (#41364)

---
 homeassistant/components/synology_dsm/config_flow.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/homeassistant/components/synology_dsm/config_flow.py b/homeassistant/components/synology_dsm/config_flow.py
index 65be8e64ebe..dd4b7cf7e10 100644
--- a/homeassistant/components/synology_dsm/config_flow.py
+++ b/homeassistant/components/synology_dsm/config_flow.py
@@ -126,7 +126,7 @@ class SynologyDSMFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
             else:
                 port = DEFAULT_PORT
 
-        api = SynologyDSM(host, port, username, password, use_ssl)
+        api = SynologyDSM(host, port, username, password, use_ssl, timeout=30)
 
         try:
             serial = await self.hass.async_add_executor_job(

From ac87c0eea2d7d88ffbb43c76cb5e96478a5f6d6c Mon Sep 17 00:00:00 2001
From: Paulus Schoutsen <balloob@gmail.com>
Date: Wed, 7 Oct 2020 09:32:12 +0200
Subject: [PATCH 44/82] Add additionalAttributes to Alexa discovery payload
 (#41370)

---
 homeassistant/components/alexa/entities.py | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/homeassistant/components/alexa/entities.py b/homeassistant/components/alexa/entities.py
index bd68e4ad926..53cf35dfe75 100644
--- a/homeassistant/components/alexa/entities.py
+++ b/homeassistant/components/alexa/entities.py
@@ -33,6 +33,7 @@ from homeassistant.const import (
     CONF_NAME,
     TEMP_CELSIUS,
     TEMP_FAHRENHEIT,
+    __version__,
 )
 from homeassistant.core import HomeAssistant, State, callback
 from homeassistant.helpers import network
@@ -286,6 +287,12 @@ class AlexaEntity:
             "friendlyName": self.friendly_name(),
             "description": self.description(),
             "manufacturerName": "Home Assistant",
+            "additionalAttributes": {
+                "manufacturer": "Home Assistant",
+                "model": self.entity.domain,
+                "softwareVersion": __version__,
+                "customIdentifier": self.entity_id,
+            },
         }
 
         locale = self.config.locale

From aa8e336af50dec8ee2c8eda22123cd06352186db Mon Sep 17 00:00:00 2001
From: Alexei Chetroi <lexoid@gmail.com>
Date: Tue, 6 Oct 2020 19:15:49 -0400
Subject: [PATCH 45/82] Bump up zha dependency to 0.26.0 (#41371)

---
 homeassistant/components/zha/manifest.json | 2 +-
 requirements_all.txt                       | 2 +-
 requirements_test_all.txt                  | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/homeassistant/components/zha/manifest.json b/homeassistant/components/zha/manifest.json
index a26cd6cc8e6..414a8721275 100644
--- a/homeassistant/components/zha/manifest.json
+++ b/homeassistant/components/zha/manifest.json
@@ -9,7 +9,7 @@
     "zha-quirks==0.0.45",
     "zigpy-cc==0.5.2",
     "zigpy-deconz==0.10.0",
-    "zigpy==0.25.0",
+    "zigpy==0.26.0",
     "zigpy-xbee==0.13.0",
     "zigpy-zigate==0.6.2",
     "zigpy-znp==0.2.1"
diff --git a/requirements_all.txt b/requirements_all.txt
index 58302505469..e927d402f2e 100644
--- a/requirements_all.txt
+++ b/requirements_all.txt
@@ -2332,7 +2332,7 @@ zigpy-zigate==0.6.2
 zigpy-znp==0.2.1
 
 # homeassistant.components.zha
-zigpy==0.25.0
+zigpy==0.26.0
 
 # homeassistant.components.zoneminder
 zm-py==0.4.0
diff --git a/requirements_test_all.txt b/requirements_test_all.txt
index 2454f3e9438..c2801e4e5d5 100644
--- a/requirements_test_all.txt
+++ b/requirements_test_all.txt
@@ -1089,7 +1089,7 @@ zigpy-zigate==0.6.2
 zigpy-znp==0.2.1
 
 # homeassistant.components.zha
-zigpy==0.25.0
+zigpy==0.26.0
 
 # homeassistant.components.zoneminder
 zm-py==0.4.0

From c3e679f69b1107cf7a0a0aa445f3eb50e1a94a59 Mon Sep 17 00:00:00 2001
From: Glenn Waters <gwwaters@gmail.com>
Date: Wed, 7 Oct 2020 04:36:49 -0400
Subject: [PATCH 46/82] Fix elkm1 changed by (#41378)

---
 .../components/elkm1/alarm_control_panel.py    | 18 ++++++++----------
 homeassistant/components/elkm1/manifest.json   |  2 +-
 requirements_all.txt                           |  2 +-
 requirements_test_all.txt                      |  2 +-
 4 files changed, 11 insertions(+), 13 deletions(-)

diff --git a/homeassistant/components/elkm1/alarm_control_panel.py b/homeassistant/components/elkm1/alarm_control_panel.py
index 1c299e68803..3bcacde64b9 100644
--- a/homeassistant/components/elkm1/alarm_control_panel.py
+++ b/homeassistant/components/elkm1/alarm_control_panel.py
@@ -155,18 +155,16 @@ class ElkArea(ElkAttachedEntity, AlarmControlPanelEntity, RestoreEntity):
             self.async_write_ha_state()
 
     def _watch_area(self, area, changeset):
-        if not changeset.get("log_event"):
+        last_log = changeset.get("last_log")
+        if not last_log:
+            return
+        # user_number only set for arm/disarm logs
+        if not last_log.get("user_number"):
             return
         self._changed_by_keypad = None
-        self._changed_by_id = area.log_number
-        self._changed_by = username(self._elk, area.log_number - 1)
-        self._changed_by_time = "%04d-%02d-%02dT%02d:%02d" % (
-            area.log_year,
-            area.log_month,
-            area.log_day,
-            area.log_hour,
-            area.log_minute,
-        )
+        self._changed_by_id = last_log["user_number"]
+        self._changed_by = username(self._elk, self._changed_by_id - 1)
+        self._changed_by_time = last_log["timestamp"]
         self.async_write_ha_state()
 
     @property
diff --git a/homeassistant/components/elkm1/manifest.json b/homeassistant/components/elkm1/manifest.json
index ca694157ba7..dd62c3a4989 100644
--- a/homeassistant/components/elkm1/manifest.json
+++ b/homeassistant/components/elkm1/manifest.json
@@ -2,7 +2,7 @@
   "domain": "elkm1",
   "name": "Elk-M1 Control",
   "documentation": "https://www.home-assistant.io/integrations/elkm1",
-  "requirements": ["elkm1-lib==0.7.19"],
+  "requirements": ["elkm1-lib==0.8.0"],
   "codeowners": ["@gwww", "@bdraco"],
   "config_flow": true
 }
diff --git a/requirements_all.txt b/requirements_all.txt
index e927d402f2e..6aa3e39b844 100644
--- a/requirements_all.txt
+++ b/requirements_all.txt
@@ -538,7 +538,7 @@ elgato==0.2.0
 eliqonline==1.2.2
 
 # homeassistant.components.elkm1
-elkm1-lib==0.7.19
+elkm1-lib==0.8.0
 
 # homeassistant.components.mobile_app
 emoji==0.5.4
diff --git a/requirements_test_all.txt b/requirements_test_all.txt
index c2801e4e5d5..aceb3b10d2c 100644
--- a/requirements_test_all.txt
+++ b/requirements_test_all.txt
@@ -278,7 +278,7 @@ eebrightbox==0.0.4
 elgato==0.2.0
 
 # homeassistant.components.elkm1
-elkm1-lib==0.7.19
+elkm1-lib==0.8.0
 
 # homeassistant.components.mobile_app
 emoji==0.5.4

From 088fb7eff338ea8ab69bc5c5bf068312e39c339c Mon Sep 17 00:00:00 2001
From: Paulus Schoutsen <balloob@gmail.com>
Date: Wed, 7 Oct 2020 13:49:45 +0200
Subject: [PATCH 47/82] Reduce Somfy polling (#41389)

---
 homeassistant/components/somfy/__init__.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/homeassistant/components/somfy/__init__.py b/homeassistant/components/somfy/__init__.py
index fbc76e7c938..c3aa3a58837 100644
--- a/homeassistant/components/somfy/__init__.py
+++ b/homeassistant/components/somfy/__init__.py
@@ -28,7 +28,7 @@ DEVICES = "devices"
 
 _LOGGER = logging.getLogger(__name__)
 
-SCAN_INTERVAL = timedelta(seconds=30)
+SCAN_INTERVAL = timedelta(minutes=1)
 
 
 CONF_OPTIMISTIC = "optimistic"

From f4991794d409c641905deff42ccebfb0c763b1ce Mon Sep 17 00:00:00 2001
From: Martin Hjelmare <marhje52@gmail.com>
Date: Wed, 7 Oct 2020 16:28:49 +0200
Subject: [PATCH 48/82] Revert zoneminder config flow (#41395)

---
 .coveragerc                                   |   1 +
 CODEOWNERS                                    |   2 +-
 .../components/zoneminder/__init__.py         | 192 ++++++------------
 .../components/zoneminder/binary_sensor.py    |  34 +---
 homeassistant/components/zoneminder/camera.py |  41 ++--
 homeassistant/components/zoneminder/common.py | 110 ----------
 .../components/zoneminder/config_flow.py      |  99 ---------
 homeassistant/components/zoneminder/const.py  |  14 --
 .../components/zoneminder/manifest.json       |   3 +-
 homeassistant/components/zoneminder/sensor.py |  73 ++-----
 .../components/zoneminder/services.yaml       |   7 +-
 .../components/zoneminder/strings.json        |  28 ---
 homeassistant/components/zoneminder/switch.py |  70 ++-----
 homeassistant/generated/config_flows.py       |   1 -
 requirements_test_all.txt                     |   3 -
 tests/components/zoneminder/__init__.py       |   1 -
 .../zoneminder/test_binary_sensor.py          |  65 ------
 tests/components/zoneminder/test_camera.py    |  89 --------
 .../components/zoneminder/test_config_flow.py | 119 -----------
 tests/components/zoneminder/test_init.py      | 122 -----------
 tests/components/zoneminder/test_sensor.py    | 167 ---------------
 tests/components/zoneminder/test_switch.py    | 126 ------------
 22 files changed, 124 insertions(+), 1243 deletions(-)
 delete mode 100644 homeassistant/components/zoneminder/common.py
 delete mode 100644 homeassistant/components/zoneminder/config_flow.py
 delete mode 100644 homeassistant/components/zoneminder/const.py
 delete mode 100644 homeassistant/components/zoneminder/strings.json
 delete mode 100644 tests/components/zoneminder/__init__.py
 delete mode 100644 tests/components/zoneminder/test_binary_sensor.py
 delete mode 100644 tests/components/zoneminder/test_camera.py
 delete mode 100644 tests/components/zoneminder/test_config_flow.py
 delete mode 100644 tests/components/zoneminder/test_init.py
 delete mode 100644 tests/components/zoneminder/test_sensor.py
 delete mode 100644 tests/components/zoneminder/test_switch.py

diff --git a/.coveragerc b/.coveragerc
index f843b280c21..03929d4ce39 100644
--- a/.coveragerc
+++ b/.coveragerc
@@ -1050,6 +1050,7 @@ omit =
     homeassistant/components/zhong_hong/climate.py
     homeassistant/components/xbee/*
     homeassistant/components/ziggo_mediabox_xl/media_player.py
+    homeassistant/components/zoneminder/*
     homeassistant/components/supla/*
     homeassistant/components/zwave/util.py
     homeassistant/components/ozw/__init__.py
diff --git a/CODEOWNERS b/CODEOWNERS
index ede90722253..31a7bc6356b 100644
--- a/CODEOWNERS
+++ b/CODEOWNERS
@@ -512,7 +512,7 @@ homeassistant/components/zerproc/* @emlove
 homeassistant/components/zha/* @dmulcahey @adminiuga
 homeassistant/components/zodiac/* @JulienTant
 homeassistant/components/zone/* @home-assistant/core
-homeassistant/components/zoneminder/* @rohankapoorcom @vangorra
+homeassistant/components/zoneminder/* @rohankapoorcom
 homeassistant/components/zwave/* @home-assistant/z-wave
 
 # Individual files
diff --git a/homeassistant/components/zoneminder/__init__.py b/homeassistant/components/zoneminder/__init__.py
index 92186b7a0b5..c631406b0e3 100644
--- a/homeassistant/components/zoneminder/__init__.py
+++ b/homeassistant/components/zoneminder/__init__.py
@@ -2,169 +2,97 @@
 import logging
 
 import voluptuous as vol
+from zoneminder.zm import ZoneMinder
 
-from homeassistant.components.binary_sensor import DOMAIN as BINARY_SENSOR_DOMAIN
-from homeassistant.components.camera import DOMAIN as CAMERA_DOMAIN
-from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN
-from homeassistant.components.switch import DOMAIN as SWITCH_DOMAIN
-import homeassistant.config_entries as config_entries
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
     ATTR_ID,
     ATTR_NAME,
     CONF_HOST,
     CONF_PASSWORD,
     CONF_PATH,
-    CONF_PLATFORM,
-    CONF_SOURCE,
     CONF_SSL,
     CONF_USERNAME,
     CONF_VERIFY_SSL,
 )
-from homeassistant.core import HomeAssistant, callback
-from homeassistant.exceptions import ConfigEntryNotReady
-from homeassistant.helpers import config_validation as cv
-
-from . import const
-from .common import (
-    ClientAvailabilityResult,
-    async_test_client_availability,
-    create_client_from_config,
-    del_client_from_data,
-    get_client_from_data,
-    is_client_in_data,
-    set_client_to_data,
-    set_platform_configs,
-)
+import homeassistant.helpers.config_validation as cv
+from homeassistant.helpers.discovery import async_load_platform
 
 _LOGGER = logging.getLogger(__name__)
-PLATFORM_DOMAINS = tuple(
-    [BINARY_SENSOR_DOMAIN, CAMERA_DOMAIN, SENSOR_DOMAIN, SWITCH_DOMAIN]
-)
+
+CONF_PATH_ZMS = "path_zms"
+
+DEFAULT_PATH = "/zm/"
+DEFAULT_PATH_ZMS = "/zm/cgi-bin/nph-zms"
+DEFAULT_SSL = False
+DEFAULT_TIMEOUT = 10
+DEFAULT_VERIFY_SSL = True
+DOMAIN = "zoneminder"
 
 HOST_CONFIG_SCHEMA = vol.Schema(
     {
         vol.Required(CONF_HOST): cv.string,
         vol.Optional(CONF_PASSWORD): cv.string,
-        vol.Optional(CONF_PATH, default=const.DEFAULT_PATH): cv.string,
-        vol.Optional(const.CONF_PATH_ZMS, default=const.DEFAULT_PATH_ZMS): cv.string,
-        vol.Optional(CONF_SSL, default=const.DEFAULT_SSL): cv.boolean,
+        vol.Optional(CONF_PATH, default=DEFAULT_PATH): cv.string,
+        vol.Optional(CONF_PATH_ZMS, default=DEFAULT_PATH_ZMS): cv.string,
+        vol.Optional(CONF_SSL, default=DEFAULT_SSL): cv.boolean,
         vol.Optional(CONF_USERNAME): cv.string,
-        vol.Optional(CONF_VERIFY_SSL, default=const.DEFAULT_VERIFY_SSL): cv.boolean,
+        vol.Optional(CONF_VERIFY_SSL, default=DEFAULT_VERIFY_SSL): cv.boolean,
     }
 )
 
-CONFIG_SCHEMA = vol.All(
-    cv.deprecated(const.DOMAIN, invalidation_version="0.118"),
-    vol.Schema(
-        {const.DOMAIN: vol.All(cv.ensure_list, [HOST_CONFIG_SCHEMA])},
-        extra=vol.ALLOW_EXTRA,
-    ),
+CONFIG_SCHEMA = vol.Schema(
+    {DOMAIN: vol.All(cv.ensure_list, [HOST_CONFIG_SCHEMA])}, extra=vol.ALLOW_EXTRA
 )
 
+SERVICE_SET_RUN_STATE = "set_run_state"
 SET_RUN_STATE_SCHEMA = vol.Schema(
     {vol.Required(ATTR_ID): cv.string, vol.Required(ATTR_NAME): cv.string}
 )
 
 
-async def async_setup(hass: HomeAssistant, base_config: dict):
+def setup(hass, config):
     """Set up the ZoneMinder component."""
 
-    # Collect the platform specific configs. It's necessary to collect these configs
-    # here instead of the platform's setup_platform function because the invocation order
-    # of setup_platform and async_setup_entry is not consistent.
-    set_platform_configs(
-        hass,
-        SENSOR_DOMAIN,
-        [
-            platform_config
-            for platform_config in base_config.get(SENSOR_DOMAIN, [])
-            if platform_config[CONF_PLATFORM] == const.DOMAIN
-        ],
-    )
-    set_platform_configs(
-        hass,
-        SWITCH_DOMAIN,
-        [
-            platform_config
-            for platform_config in base_config.get(SWITCH_DOMAIN, [])
-            if platform_config[CONF_PLATFORM] == const.DOMAIN
-        ],
+    hass.data[DOMAIN] = {}
+
+    success = True
+
+    for conf in config[DOMAIN]:
+        protocol = "https" if conf[CONF_SSL] else "http"
+
+        host_name = conf[CONF_HOST]
+        server_origin = f"{protocol}://{host_name}"
+        zm_client = ZoneMinder(
+            server_origin,
+            conf.get(CONF_USERNAME),
+            conf.get(CONF_PASSWORD),
+            conf.get(CONF_PATH),
+            conf.get(CONF_PATH_ZMS),
+            conf.get(CONF_VERIFY_SSL),
+        )
+        hass.data[DOMAIN][host_name] = zm_client
+
+        success = zm_client.login() and success
+
+    def set_active_state(call):
+        """Set the ZoneMinder run state to the given state name."""
+        zm_id = call.data[ATTR_ID]
+        state_name = call.data[ATTR_NAME]
+        if zm_id not in hass.data[DOMAIN]:
+            _LOGGER.error("Invalid ZoneMinder host provided: %s", zm_id)
+        if not hass.data[DOMAIN][zm_id].set_active_state(state_name):
+            _LOGGER.error(
+                "Unable to change ZoneMinder state. Host: %s, state: %s",
+                zm_id,
+                state_name,
+            )
+
+    hass.services.register(
+        DOMAIN, SERVICE_SET_RUN_STATE, set_active_state, schema=SET_RUN_STATE_SCHEMA
     )
 
-    config = base_config.get(const.DOMAIN)
+    hass.async_create_task(
+        async_load_platform(hass, "binary_sensor", DOMAIN, {}, config)
+    )
 
-    if not config:
-        return True
-
-    for config_item in config:
-        hass.async_create_task(
-            hass.config_entries.flow.async_init(
-                const.DOMAIN,
-                context={CONF_SOURCE: config_entries.SOURCE_IMPORT},
-                data=config_item,
-            )
-        )
-
-    return True
-
-
-async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry) -> bool:
-    """Set up Zoneminder config entry."""
-    zm_client = create_client_from_config(config_entry.data)
-
-    result = await async_test_client_availability(hass, zm_client)
-    if result != ClientAvailabilityResult.AVAILABLE:
-        raise ConfigEntryNotReady
-
-    set_client_to_data(hass, config_entry.unique_id, zm_client)
-
-    for platform_domain in PLATFORM_DOMAINS:
-        hass.async_create_task(
-            hass.config_entries.async_forward_entry_setup(config_entry, platform_domain)
-        )
-
-    if not hass.services.has_service(const.DOMAIN, const.SERVICE_SET_RUN_STATE):
-
-        @callback
-        def set_active_state(call):
-            """Set the ZoneMinder run state to the given state name."""
-            zm_id = call.data[ATTR_ID]
-            state_name = call.data[ATTR_NAME]
-            if not is_client_in_data(hass, zm_id):
-                _LOGGER.error("Invalid ZoneMinder host provided: %s", zm_id)
-                return
-
-            if not get_client_from_data(hass, zm_id).set_active_state(state_name):
-                _LOGGER.error(
-                    "Unable to change ZoneMinder state. Host: %s, state: %s",
-                    zm_id,
-                    state_name,
-                )
-
-        hass.services.async_register(
-            const.DOMAIN,
-            const.SERVICE_SET_RUN_STATE,
-            set_active_state,
-            schema=SET_RUN_STATE_SCHEMA,
-        )
-
-    return True
-
-
-async def async_unload_entry(hass: HomeAssistant, config_entry: ConfigEntry) -> bool:
-    """Unload Zoneminder config entry."""
-    for platform_domain in PLATFORM_DOMAINS:
-        hass.async_create_task(
-            hass.config_entries.async_forward_entry_unload(
-                config_entry, platform_domain
-            )
-        )
-
-    # If this is the last config to exist, remove the service too.
-    if len(hass.config_entries.async_entries(const.DOMAIN)) <= 1:
-        hass.services.async_remove(const.DOMAIN, const.SERVICE_SET_RUN_STATE)
-
-    del_client_from_data(hass, config_entry.unique_id)
-
-    return True
+    return success
diff --git a/homeassistant/components/zoneminder/binary_sensor.py b/homeassistant/components/zoneminder/binary_sensor.py
index 73f7ce2f4c9..73d6877ef2d 100644
--- a/homeassistant/components/zoneminder/binary_sensor.py
+++ b/homeassistant/components/zoneminder/binary_sensor.py
@@ -1,43 +1,29 @@
 """Support for ZoneMinder binary sensors."""
-from typing import Callable, List, Optional
-
-from zoneminder.zm import ZoneMinder
-
 from homeassistant.components.binary_sensor import (
     DEVICE_CLASS_CONNECTIVITY,
     BinarySensorEntity,
 )
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity import Entity
 
-from .common import get_client_from_data
+from . import DOMAIN as ZONEMINDER_DOMAIN
 
 
-async def async_setup_entry(
-    hass: HomeAssistant,
-    config_entry: ConfigEntry,
-    async_add_entities: Callable[[List[Entity], Optional[bool]], None],
-) -> None:
-    """Set up the sensor config entry."""
-    zm_client = get_client_from_data(hass, config_entry.unique_id)
-    async_add_entities([ZMAvailabilitySensor(zm_client, config_entry)])
+async def async_setup_platform(hass, config, add_entities, discovery_info=None):
+    """Set up the ZoneMinder binary sensor platform."""
+    sensors = []
+    for host_name, zm_client in hass.data[ZONEMINDER_DOMAIN].items():
+        sensors.append(ZMAvailabilitySensor(host_name, zm_client))
+    add_entities(sensors)
+    return True
 
 
 class ZMAvailabilitySensor(BinarySensorEntity):
     """Representation of the availability of ZoneMinder as a binary sensor."""
 
-    def __init__(self, client: ZoneMinder, config_entry: ConfigEntry):
+    def __init__(self, host_name, client):
         """Initialize availability sensor."""
         self._state = None
-        self._name = config_entry.unique_id
+        self._name = host_name
         self._client = client
-        self._config_entry = config_entry
-
-    @property
-    def unique_id(self) -> Optional[str]:
-        """Return a unique ID."""
-        return f"{self._config_entry.unique_id}_availability"
 
     @property
     def name(self):
diff --git a/homeassistant/components/zoneminder/camera.py b/homeassistant/components/zoneminder/camera.py
index c4ef1b14772..6144fe11226 100644
--- a/homeassistant/components/zoneminder/camera.py
+++ b/homeassistant/components/zoneminder/camera.py
@@ -1,8 +1,5 @@
 """Support for ZoneMinder camera streaming."""
 import logging
-from typing import Callable, List, Optional
-
-from zoneminder.monitor import Monitor
 
 from homeassistant.components.mjpeg.camera import (
     CONF_MJPEG_URL,
@@ -10,12 +7,9 @@ from homeassistant.components.mjpeg.camera import (
     MjpegCamera,
     filter_urllib3_logging,
 )
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_NAME, CONF_VERIFY_SSL
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity import Entity
 
-from .common import get_client_from_data
+from . import DOMAIN as ZONEMINDER_DOMAIN
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -23,28 +17,23 @@ _LOGGER = logging.getLogger(__name__)
 def setup_platform(hass, config, add_entities, discovery_info=None):
     """Set up the ZoneMinder cameras."""
     filter_urllib3_logging()
+    cameras = []
+    for zm_client in hass.data[ZONEMINDER_DOMAIN].values():
+        monitors = zm_client.get_monitors()
+        if not monitors:
+            _LOGGER.warning("Could not fetch monitors from ZoneMinder host: %s")
+            return
 
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    config_entry: ConfigEntry,
-    async_add_entities: Callable[[List[Entity], Optional[bool]], None],
-) -> None:
-    """Set up the sensor config entry."""
-    zm_client = get_client_from_data(hass, config_entry.unique_id)
-
-    async_add_entities(
-        [
-            ZoneMinderCamera(monitor, zm_client.verify_ssl, config_entry)
-            for monitor in await hass.async_add_job(zm_client.get_monitors)
-        ]
-    )
+        for monitor in monitors:
+            _LOGGER.info("Initializing camera %s", monitor.id)
+            cameras.append(ZoneMinderCamera(monitor, zm_client.verify_ssl))
+    add_entities(cameras)
 
 
 class ZoneMinderCamera(MjpegCamera):
     """Representation of a ZoneMinder Monitor Stream."""
 
-    def __init__(self, monitor: Monitor, verify_ssl: bool, config_entry: ConfigEntry):
+    def __init__(self, monitor, verify_ssl):
         """Initialize as a subclass of MjpegCamera."""
         device_info = {
             CONF_NAME: monitor.name,
@@ -56,12 +45,6 @@ class ZoneMinderCamera(MjpegCamera):
         self._is_recording = None
         self._is_available = None
         self._monitor = monitor
-        self._config_entry = config_entry
-
-    @property
-    def unique_id(self) -> Optional[str]:
-        """Return a unique ID."""
-        return f"{self._config_entry.unique_id}_{self._monitor.id}_camera"
 
     @property
     def should_poll(self):
diff --git a/homeassistant/components/zoneminder/common.py b/homeassistant/components/zoneminder/common.py
deleted file mode 100644
index 970289ea136..00000000000
--- a/homeassistant/components/zoneminder/common.py
+++ /dev/null
@@ -1,110 +0,0 @@
-"""Common code for the ZoneMinder component."""
-from enum import Enum
-from typing import List
-
-import requests
-from zoneminder.zm import ZoneMinder
-
-from homeassistant.const import (
-    CONF_HOST,
-    CONF_PASSWORD,
-    CONF_PATH,
-    CONF_SSL,
-    CONF_USERNAME,
-    CONF_VERIFY_SSL,
-)
-from homeassistant.core import HomeAssistant
-
-from . import const
-
-
-def prime_domain_data(hass: HomeAssistant) -> None:
-    """Prime the data structures."""
-    hass.data.setdefault(const.DOMAIN, {})
-
-
-def prime_platform_configs(hass: HomeAssistant, domain: str) -> None:
-    """Prime the data structures."""
-    prime_domain_data(hass)
-    hass.data[const.DOMAIN].setdefault(const.PLATFORM_CONFIGS, {})
-    hass.data[const.DOMAIN][const.PLATFORM_CONFIGS].setdefault(domain, [])
-
-
-def set_platform_configs(hass: HomeAssistant, domain: str, configs: List[dict]) -> None:
-    """Set platform configs."""
-    prime_platform_configs(hass, domain)
-    hass.data[const.DOMAIN][const.PLATFORM_CONFIGS][domain] = configs
-
-
-def get_platform_configs(hass: HomeAssistant, domain: str) -> List[dict]:
-    """Get platform configs."""
-    prime_platform_configs(hass, domain)
-    return hass.data[const.DOMAIN][const.PLATFORM_CONFIGS][domain]
-
-
-def prime_config_data(hass: HomeAssistant, unique_id: str) -> None:
-    """Prime the data structures."""
-    prime_domain_data(hass)
-    hass.data[const.DOMAIN].setdefault(const.CONFIG_DATA, {})
-    hass.data[const.DOMAIN][const.CONFIG_DATA].setdefault(unique_id, {})
-
-
-def set_client_to_data(hass: HomeAssistant, unique_id: str, client: ZoneMinder) -> None:
-    """Put a ZoneMinder client in the Home Assistant data."""
-    prime_config_data(hass, unique_id)
-    hass.data[const.DOMAIN][const.CONFIG_DATA][unique_id][const.API_CLIENT] = client
-
-
-def is_client_in_data(hass: HomeAssistant, unique_id: str) -> bool:
-    """Check if ZoneMinder client is in the Home Assistant data."""
-    prime_config_data(hass, unique_id)
-    return const.API_CLIENT in hass.data[const.DOMAIN][const.CONFIG_DATA][unique_id]
-
-
-def get_client_from_data(hass: HomeAssistant, unique_id: str) -> ZoneMinder:
-    """Get a ZoneMinder client from the Home Assistant data."""
-    prime_config_data(hass, unique_id)
-    return hass.data[const.DOMAIN][const.CONFIG_DATA][unique_id][const.API_CLIENT]
-
-
-def del_client_from_data(hass: HomeAssistant, unique_id: str) -> None:
-    """Delete a ZoneMinder client from the Home Assistant data."""
-    prime_config_data(hass, unique_id)
-    del hass.data[const.DOMAIN][const.CONFIG_DATA][unique_id][const.API_CLIENT]
-
-
-def create_client_from_config(conf: dict) -> ZoneMinder:
-    """Create a new ZoneMinder client from a config."""
-    protocol = "https" if conf[CONF_SSL] else "http"
-
-    host_name = conf[CONF_HOST]
-    server_origin = f"{protocol}://{host_name}"
-
-    return ZoneMinder(
-        server_origin,
-        conf.get(CONF_USERNAME),
-        conf.get(CONF_PASSWORD),
-        conf.get(CONF_PATH),
-        conf.get(const.CONF_PATH_ZMS),
-        conf.get(CONF_VERIFY_SSL),
-    )
-
-
-class ClientAvailabilityResult(Enum):
-    """Client availability test result."""
-
-    AVAILABLE = "available"
-    ERROR_AUTH_FAIL = "auth_fail"
-    ERROR_CONNECTION_ERROR = "connection_error"
-
-
-async def async_test_client_availability(
-    hass: HomeAssistant, client: ZoneMinder
-) -> ClientAvailabilityResult:
-    """Test the availability of a ZoneMinder client."""
-    try:
-        if await hass.async_add_job(client.login):
-            return ClientAvailabilityResult.AVAILABLE
-        return ClientAvailabilityResult.ERROR_AUTH_FAIL
-    except requests.exceptions.ConnectionError:
-        return ClientAvailabilityResult.ERROR_CONNECTION_ERROR
diff --git a/homeassistant/components/zoneminder/config_flow.py b/homeassistant/components/zoneminder/config_flow.py
deleted file mode 100644
index 8b0b94107f3..00000000000
--- a/homeassistant/components/zoneminder/config_flow.py
+++ /dev/null
@@ -1,99 +0,0 @@
-"""ZoneMinder config flow."""
-from urllib.parse import urlparse
-
-import voluptuous as vol
-
-from homeassistant import config_entries
-from homeassistant.const import (
-    CONF_HOST,
-    CONF_PASSWORD,
-    CONF_PATH,
-    CONF_SOURCE,
-    CONF_SSL,
-    CONF_USERNAME,
-    CONF_VERIFY_SSL,
-)
-
-from .common import (
-    ClientAvailabilityResult,
-    async_test_client_availability,
-    create_client_from_config,
-)
-from .const import (
-    CONF_PATH_ZMS,
-    DEFAULT_PATH,
-    DEFAULT_PATH_ZMS,
-    DEFAULT_SSL,
-    DEFAULT_VERIFY_SSL,
-)
-from .const import DOMAIN  # pylint: disable=unused-import
-
-
-class ZoneminderFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
-    """Flow handler for zoneminder integration."""
-
-    VERSION = 1
-    CONNECTION_CLASS = config_entries.CONN_CLASS_LOCAL_POLL
-
-    async def async_step_import(self, config: dict):
-        """Handle a flow initialized by import."""
-        return await self.async_step_finish(
-            {**config, **{CONF_SOURCE: config_entries.SOURCE_IMPORT}}
-        )
-
-    async def async_step_user(self, user_input: dict = None):
-        """Handle user step."""
-        user_input = user_input or {}
-        errors = {}
-
-        if user_input:
-            zm_client = create_client_from_config(user_input)
-            result = await async_test_client_availability(self.hass, zm_client)
-            if result == ClientAvailabilityResult.AVAILABLE:
-                return await self.async_step_finish(user_input)
-
-            errors["base"] = result.value
-
-        return self.async_show_form(
-            step_id=config_entries.SOURCE_USER,
-            data_schema=vol.Schema(
-                {
-                    vol.Required(CONF_HOST, default=user_input.get(CONF_HOST)): str,
-                    vol.Optional(
-                        CONF_USERNAME, default=user_input.get(CONF_USERNAME, "")
-                    ): str,
-                    vol.Optional(
-                        CONF_PASSWORD, default=user_input.get(CONF_PASSWORD, "")
-                    ): str,
-                    vol.Optional(
-                        CONF_PATH, default=user_input.get(CONF_PATH, DEFAULT_PATH)
-                    ): str,
-                    vol.Optional(
-                        CONF_PATH_ZMS,
-                        default=user_input.get(CONF_PATH_ZMS, DEFAULT_PATH_ZMS),
-                    ): str,
-                    vol.Optional(
-                        CONF_SSL, default=user_input.get(CONF_SSL, DEFAULT_SSL)
-                    ): bool,
-                    vol.Optional(
-                        CONF_VERIFY_SSL,
-                        default=user_input.get(CONF_VERIFY_SSL, DEFAULT_VERIFY_SSL),
-                    ): bool,
-                }
-            ),
-            errors=errors,
-        )
-
-    async def async_step_finish(self, config: dict):
-        """Finish config flow."""
-        zm_client = create_client_from_config(config)
-        hostname = urlparse(zm_client.get_zms_url()).hostname
-        result = await async_test_client_availability(self.hass, zm_client)
-
-        if result != ClientAvailabilityResult.AVAILABLE:
-            return self.async_abort(reason=str(result.value))
-
-        await self.async_set_unique_id(hostname)
-        self._abort_if_unique_id_configured(config)
-
-        return self.async_create_entry(title=hostname, data=config)
diff --git a/homeassistant/components/zoneminder/const.py b/homeassistant/components/zoneminder/const.py
deleted file mode 100644
index ad890a1d4d6..00000000000
--- a/homeassistant/components/zoneminder/const.py
+++ /dev/null
@@ -1,14 +0,0 @@
-"""Constants for zoneminder component."""
-
-CONF_PATH_ZMS = "path_zms"
-
-DEFAULT_PATH = "/zm/"
-DEFAULT_PATH_ZMS = "/zm/cgi-bin/nph-zms"
-DEFAULT_SSL = False
-DEFAULT_VERIFY_SSL = True
-DOMAIN = "zoneminder"
-SERVICE_SET_RUN_STATE = "set_run_state"
-
-PLATFORM_CONFIGS = "platform_configs"
-CONFIG_DATA = "config_data"
-API_CLIENT = "api_client"
diff --git a/homeassistant/components/zoneminder/manifest.json b/homeassistant/components/zoneminder/manifest.json
index 13bec8c4d9a..b3a87510e5a 100644
--- a/homeassistant/components/zoneminder/manifest.json
+++ b/homeassistant/components/zoneminder/manifest.json
@@ -1,8 +1,7 @@
 {
   "domain": "zoneminder",
   "name": "ZoneMinder",
-  "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/zoneminder",
   "requirements": ["zm-py==0.4.0"],
-  "codeowners": ["@rohankapoorcom", "@vangorra"]
+  "codeowners": ["@rohankapoorcom"]
 }
diff --git a/homeassistant/components/zoneminder/sensor.py b/homeassistant/components/zoneminder/sensor.py
index 8605e842813..75531e79e13 100644
--- a/homeassistant/components/zoneminder/sensor.py
+++ b/homeassistant/components/zoneminder/sensor.py
@@ -1,19 +1,15 @@
 """Support for ZoneMinder sensors."""
 import logging
-from typing import Callable, List, Optional
 
 import voluptuous as vol
-from zoneminder.monitor import Monitor, TimePeriod
-from zoneminder.zm import ZoneMinder
+from zoneminder.monitor import TimePeriod
 
-from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN, PLATFORM_SCHEMA
-from homeassistant.config_entries import ConfigEntry
+from homeassistant.components.sensor import PLATFORM_SCHEMA
 from homeassistant.const import CONF_MONITORED_CONDITIONS
-from homeassistant.core import HomeAssistant
 import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.entity import Entity
 
-from .common import get_client_from_data, get_platform_configs
+from . import DOMAIN as ZONEMINDER_DOMAIN
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -41,50 +37,35 @@ PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
 )
 
 
-async def async_setup_entry(
-    hass: HomeAssistant,
-    config_entry: ConfigEntry,
-    async_add_entities: Callable[[List[Entity], Optional[bool]], None],
-) -> None:
-    """Set up the sensor config entry."""
-    zm_client = get_client_from_data(hass, config_entry.unique_id)
-    monitors = await hass.async_add_job(zm_client.get_monitors)
-
-    if not monitors:
-        _LOGGER.warning("Did not fetch any monitors from ZoneMinder")
+def setup_platform(hass, config, add_entities, discovery_info=None):
+    """Set up the ZoneMinder sensor platform."""
+    include_archived = config.get(CONF_INCLUDE_ARCHIVED)
 
     sensors = []
-    for monitor in monitors:
-        sensors.append(ZMSensorMonitors(monitor, config_entry))
+    for zm_client in hass.data[ZONEMINDER_DOMAIN].values():
+        monitors = zm_client.get_monitors()
+        if not monitors:
+            _LOGGER.warning("Could not fetch any monitors from ZoneMinder")
 
-        for config in get_platform_configs(hass, SENSOR_DOMAIN):
-            include_archived = config.get(CONF_INCLUDE_ARCHIVED)
+        for monitor in monitors:
+            sensors.append(ZMSensorMonitors(monitor))
 
             for sensor in config[CONF_MONITORED_CONDITIONS]:
-                sensors.append(
-                    ZMSensorEvents(monitor, include_archived, sensor, config_entry)
-                )
+                sensors.append(ZMSensorEvents(monitor, include_archived, sensor))
 
-    sensors.append(ZMSensorRunState(zm_client, config_entry))
-
-    async_add_entities(sensors, True)
+        sensors.append(ZMSensorRunState(zm_client))
+    add_entities(sensors)
 
 
 class ZMSensorMonitors(Entity):
     """Get the status of each ZoneMinder monitor."""
 
-    def __init__(self, monitor: Monitor, config_entry: ConfigEntry):
+    def __init__(self, monitor):
         """Initialize monitor sensor."""
         self._monitor = monitor
-        self._config_entry = config_entry
         self._state = None
         self._is_available = None
 
-    @property
-    def unique_id(self) -> Optional[str]:
-        """Return a unique ID."""
-        return f"{self._config_entry.unique_id}_{self._monitor.id}_status"
-
     @property
     def name(self):
         """Return the name of the sensor."""
@@ -113,26 +94,14 @@ class ZMSensorMonitors(Entity):
 class ZMSensorEvents(Entity):
     """Get the number of events for each monitor."""
 
-    def __init__(
-        self,
-        monitor: Monitor,
-        include_archived: bool,
-        sensor_type: str,
-        config_entry: ConfigEntry,
-    ):
+    def __init__(self, monitor, include_archived, sensor_type):
         """Initialize event sensor."""
 
         self._monitor = monitor
         self._include_archived = include_archived
         self.time_period = TimePeriod.get_time_period(sensor_type)
-        self._config_entry = config_entry
         self._state = None
 
-    @property
-    def unique_id(self) -> Optional[str]:
-        """Return a unique ID."""
-        return f"{self._config_entry.unique_id}_{self._monitor.id}_{self.time_period.value}_{self._include_archived}_events"
-
     @property
     def name(self):
         """Return the name of the sensor."""
@@ -156,17 +125,11 @@ class ZMSensorEvents(Entity):
 class ZMSensorRunState(Entity):
     """Get the ZoneMinder run state."""
 
-    def __init__(self, client: ZoneMinder, config_entry: ConfigEntry):
+    def __init__(self, client):
         """Initialize run state sensor."""
         self._state = None
         self._is_available = None
         self._client = client
-        self._config_entry = config_entry
-
-    @property
-    def unique_id(self) -> Optional[str]:
-        """Return a unique ID."""
-        return f"{self._config_entry.unique_id}_runstate"
 
     @property
     def name(self):
diff --git a/homeassistant/components/zoneminder/services.yaml b/homeassistant/components/zoneminder/services.yaml
index 52e8a3bf0bb..a6fb85b641d 100644
--- a/homeassistant/components/zoneminder/services.yaml
+++ b/homeassistant/components/zoneminder/services.yaml
@@ -1,9 +1,6 @@
 set_run_state:
-  description: "Set the ZoneMinder run state"
+  description: Set the ZoneMinder run state
   fields:
-    id:
-      description: "The host name or IP address of the ZoneMinder instance."
-      example: "10.10.0.2"
     name:
-      description: "The string name of the ZoneMinder run state to set as active."
+      description: The string name of the ZoneMinder run state to set as active.
       example: "Home"
diff --git a/homeassistant/components/zoneminder/strings.json b/homeassistant/components/zoneminder/strings.json
deleted file mode 100644
index 8b722c9af2c..00000000000
--- a/homeassistant/components/zoneminder/strings.json
+++ /dev/null
@@ -1,28 +0,0 @@
-{
-  "config": {
-    "flow_title": "ZoneMinder",
-    "step": {
-      "user": {
-        "title": "Add ZoneMinder Server.",
-        "data": {
-          "host": "Host and Port (ex 10.10.0.4:8010)",
-          "username": "[%key:common::config_flow::data::username%]",
-          "password": "[%key:common::config_flow::data::password%]",
-          "path": "ZM Path",
-          "path_zms": "ZMS Path",
-          "ssl": "Use SSL for connections to ZoneMinder",
-          "verify_ssl": "Verify SSL Certificate"
-        }
-      }
-    },
-    "abort": {
-      "auth_fail": "Username or password is incorrect.",
-      "connection_error": "Failed to connect to a ZoneMinder server."
-    },
-    "error": {
-      "auth_fail": "Username or password is incorrect.",
-      "connection_error": "Failed to connect to a ZoneMinder server."
-    },
-    "create_entry": { "default": "ZoneMinder server added." }
-  }
-}
diff --git a/homeassistant/components/zoneminder/switch.py b/homeassistant/components/zoneminder/switch.py
index d8d1cc78797..0428ddbf888 100644
--- a/homeassistant/components/zoneminder/switch.py
+++ b/homeassistant/components/zoneminder/switch.py
@@ -1,61 +1,41 @@
 """Support for ZoneMinder switches."""
 import logging
-from typing import Callable, List, Optional
 
 import voluptuous as vol
-from zoneminder.monitor import Monitor, MonitorState
+from zoneminder.monitor import MonitorState
 
-from homeassistant.components.switch import (
-    DOMAIN as SWITCH_DOMAIN,
-    PLATFORM_SCHEMA,
-    SwitchEntity,
-)
-from homeassistant.config_entries import ConfigEntry
+from homeassistant.components.switch import PLATFORM_SCHEMA, SwitchEntity
 from homeassistant.const import CONF_COMMAND_OFF, CONF_COMMAND_ON
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity import Entity
+import homeassistant.helpers.config_validation as cv
 
-from .common import get_client_from_data, get_platform_configs
+from . import DOMAIN as ZONEMINDER_DOMAIN
 
 _LOGGER = logging.getLogger(__name__)
 
-MONITOR_STATES = {
-    MonitorState[name].value: MonitorState[name]
-    for name in dir(MonitorState)
-    if not name.startswith("_")
-}
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
     {
-        vol.Required(CONF_COMMAND_ON): vol.All(vol.In(MONITOR_STATES.keys())),
-        vol.Required(CONF_COMMAND_OFF): vol.All(vol.In(MONITOR_STATES.keys())),
+        vol.Required(CONF_COMMAND_ON): cv.string,
+        vol.Required(CONF_COMMAND_OFF): cv.string,
     }
 )
 
 
-async def async_setup_entry(
-    hass: HomeAssistant,
-    config_entry: ConfigEntry,
-    async_add_entities: Callable[[List[Entity], Optional[bool]], None],
-) -> None:
-    """Set up the sensor config entry."""
-    zm_client = get_client_from_data(hass, config_entry.unique_id)
-    monitors = await hass.async_add_job(zm_client.get_monitors)
+def setup_platform(hass, config, add_entities, discovery_info=None):
+    """Set up the ZoneMinder switch platform."""
 
-    if not monitors:
-        _LOGGER.warning("Could not fetch monitors from ZoneMinder")
-        return
+    on_state = MonitorState(config.get(CONF_COMMAND_ON))
+    off_state = MonitorState(config.get(CONF_COMMAND_OFF))
 
     switches = []
-    for monitor in monitors:
-        for config in get_platform_configs(hass, SWITCH_DOMAIN):
-            on_state = MONITOR_STATES[config[CONF_COMMAND_ON]]
-            off_state = MONITOR_STATES[config[CONF_COMMAND_OFF]]
+    for zm_client in hass.data[ZONEMINDER_DOMAIN].values():
+        monitors = zm_client.get_monitors()
+        if not monitors:
+            _LOGGER.warning("Could not fetch monitors from ZoneMinder")
+            return
 
-            switches.append(
-                ZMSwitchMonitors(monitor, on_state, off_state, config_entry)
-            )
-
-    async_add_entities(switches, True)
+        for monitor in monitors:
+            switches.append(ZMSwitchMonitors(monitor, on_state, off_state))
+    add_entities(switches)
 
 
 class ZMSwitchMonitors(SwitchEntity):
@@ -63,25 +43,13 @@ class ZMSwitchMonitors(SwitchEntity):
 
     icon = "mdi:record-rec"
 
-    def __init__(
-        self,
-        monitor: Monitor,
-        on_state: MonitorState,
-        off_state: MonitorState,
-        config_entry: ConfigEntry,
-    ):
+    def __init__(self, monitor, on_state, off_state):
         """Initialize the switch."""
         self._monitor = monitor
         self._on_state = on_state
         self._off_state = off_state
-        self._config_entry = config_entry
         self._state = None
 
-    @property
-    def unique_id(self) -> Optional[str]:
-        """Return a unique ID."""
-        return f"{self._config_entry.unique_id}_{self._monitor.id}_switch_{self._on_state.value}_{self._off_state.value}"
-
     @property
     def name(self):
         """Return the name of the switch."""
diff --git a/homeassistant/generated/config_flows.py b/homeassistant/generated/config_flows.py
index bfd3c340e6d..095c8c9afec 100644
--- a/homeassistant/generated/config_flows.py
+++ b/homeassistant/generated/config_flows.py
@@ -217,6 +217,5 @@ FLOWS = [
     "yeelight",
     "zerproc",
     "zha",
-    "zoneminder",
     "zwave"
 ]
diff --git a/requirements_test_all.txt b/requirements_test_all.txt
index aceb3b10d2c..deff4c9aafc 100644
--- a/requirements_test_all.txt
+++ b/requirements_test_all.txt
@@ -1090,6 +1090,3 @@ zigpy-znp==0.2.1
 
 # homeassistant.components.zha
 zigpy==0.26.0
-
-# homeassistant.components.zoneminder
-zm-py==0.4.0
diff --git a/tests/components/zoneminder/__init__.py b/tests/components/zoneminder/__init__.py
deleted file mode 100644
index 9ea5189a7b9..00000000000
--- a/tests/components/zoneminder/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Tests for the zoneminder component."""
diff --git a/tests/components/zoneminder/test_binary_sensor.py b/tests/components/zoneminder/test_binary_sensor.py
deleted file mode 100644
index ee9883283e9..00000000000
--- a/tests/components/zoneminder/test_binary_sensor.py
+++ /dev/null
@@ -1,65 +0,0 @@
-"""Binary sensor tests."""
-from zoneminder.zm import ZoneMinder
-
-from homeassistant.components.zoneminder import const
-from homeassistant.config import async_process_ha_core_config
-from homeassistant.const import (
-    ATTR_ENTITY_ID,
-    CONF_HOST,
-    CONF_PASSWORD,
-    CONF_PATH,
-    CONF_SSL,
-    CONF_USERNAME,
-    CONF_VERIFY_SSL,
-)
-from homeassistant.core import DOMAIN as HASS_DOMAIN, HomeAssistant
-from homeassistant.setup import async_setup_component
-
-from tests.async_mock import MagicMock, patch
-from tests.common import MockConfigEntry
-
-
-async def test_async_setup_entry(hass: HomeAssistant) -> None:
-    """Test setup of binary sensor entities."""
-    with patch(
-        "homeassistant.components.zoneminder.common.ZoneMinder", autospec=ZoneMinder
-    ) as zoneminder_mock:
-        zm_client: ZoneMinder = MagicMock(spec=ZoneMinder)
-        zm_client.get_zms_url.return_value = "http://host1/path_zms1"
-        zm_client.login.return_value = True
-        zm_client.is_available = True
-
-        zoneminder_mock.return_value = zm_client
-
-        config_entry = MockConfigEntry(
-            domain=const.DOMAIN,
-            unique_id="host1",
-            data={
-                CONF_HOST: "host1",
-                CONF_USERNAME: "username1",
-                CONF_PASSWORD: "password1",
-                CONF_PATH: "path1",
-                const.CONF_PATH_ZMS: "path_zms1",
-                CONF_SSL: False,
-                CONF_VERIFY_SSL: True,
-            },
-        )
-        config_entry.add_to_hass(hass)
-
-        await async_process_ha_core_config(hass, {})
-        await async_setup_component(hass, HASS_DOMAIN, {})
-        await async_setup_component(hass, const.DOMAIN, {})
-        await hass.async_block_till_done()
-
-        await hass.services.async_call(
-            HASS_DOMAIN, "update_entity", {ATTR_ENTITY_ID: "binary_sensor.host1"}
-        )
-        await hass.async_block_till_done()
-        assert hass.states.get("binary_sensor.host1").state == "on"
-
-        zm_client.is_available = False
-        await hass.services.async_call(
-            HASS_DOMAIN, "update_entity", {ATTR_ENTITY_ID: "binary_sensor.host1"}
-        )
-        await hass.async_block_till_done()
-        assert hass.states.get("binary_sensor.host1").state == "off"
diff --git a/tests/components/zoneminder/test_camera.py b/tests/components/zoneminder/test_camera.py
deleted file mode 100644
index 06f4c3554df..00000000000
--- a/tests/components/zoneminder/test_camera.py
+++ /dev/null
@@ -1,89 +0,0 @@
-"""Binary sensor tests."""
-from zoneminder.monitor import Monitor
-from zoneminder.zm import ZoneMinder
-
-from homeassistant.components.zoneminder import const
-from homeassistant.config import async_process_ha_core_config
-from homeassistant.const import (
-    ATTR_ENTITY_ID,
-    CONF_HOST,
-    CONF_PASSWORD,
-    CONF_PATH,
-    CONF_SSL,
-    CONF_USERNAME,
-    CONF_VERIFY_SSL,
-)
-from homeassistant.core import DOMAIN as HASS_DOMAIN, HomeAssistant
-from homeassistant.setup import async_setup_component
-
-from tests.async_mock import MagicMock, patch
-from tests.common import MockConfigEntry
-
-
-async def test_async_setup_entry(hass: HomeAssistant) -> None:
-    """Test setup of camera entities."""
-    with patch(
-        "homeassistant.components.zoneminder.common.ZoneMinder", autospec=ZoneMinder
-    ) as zoneminder_mock:
-        monitor1 = MagicMock(spec=Monitor)
-        monitor1.name = "monitor1"
-        monitor1.mjpeg_image_url = "mjpeg_image_url1"
-        monitor1.still_image_url = "still_image_url1"
-        monitor1.is_recording = True
-        monitor1.is_available = True
-
-        monitor2 = MagicMock(spec=Monitor)
-        monitor2.name = "monitor2"
-        monitor2.mjpeg_image_url = "mjpeg_image_url2"
-        monitor2.still_image_url = "still_image_url2"
-        monitor2.is_recording = False
-        monitor2.is_available = False
-
-        zm_client: ZoneMinder = MagicMock(spec=ZoneMinder)
-        zm_client.get_zms_url.return_value = "http://host1/path_zms1"
-        zm_client.login.return_value = True
-        zm_client.get_monitors.return_value = [monitor1, monitor2]
-
-        zoneminder_mock.return_value = zm_client
-
-        config_entry = MockConfigEntry(
-            domain=const.DOMAIN,
-            unique_id="host1",
-            data={
-                CONF_HOST: "host1",
-                CONF_USERNAME: "username1",
-                CONF_PASSWORD: "password1",
-                CONF_PATH: "path1",
-                const.CONF_PATH_ZMS: "path_zms1",
-                CONF_SSL: False,
-                CONF_VERIFY_SSL: True,
-            },
-        )
-        config_entry.add_to_hass(hass)
-
-        await async_process_ha_core_config(hass, {})
-        await async_setup_component(hass, HASS_DOMAIN, {})
-        await async_setup_component(hass, const.DOMAIN, {})
-        await hass.async_block_till_done()
-
-        await hass.services.async_call(
-            HASS_DOMAIN, "update_entity", {ATTR_ENTITY_ID: "camera.monitor1"}
-        )
-        await hass.services.async_call(
-            HASS_DOMAIN, "update_entity", {ATTR_ENTITY_ID: "camera.monitor2"}
-        )
-        await hass.async_block_till_done()
-        assert hass.states.get("camera.monitor1").state == "recording"
-        assert hass.states.get("camera.monitor2").state == "unavailable"
-
-        monitor1.is_recording = False
-        monitor2.is_recording = True
-        await hass.services.async_call(
-            HASS_DOMAIN, "update_entity", {ATTR_ENTITY_ID: "camera.monitor1"}
-        )
-        await hass.services.async_call(
-            HASS_DOMAIN, "update_entity", {ATTR_ENTITY_ID: "camera.monitor2"}
-        )
-        await hass.async_block_till_done()
-        assert hass.states.get("camera.monitor1").state == "idle"
-        assert hass.states.get("camera.monitor2").state == "unavailable"
diff --git a/tests/components/zoneminder/test_config_flow.py b/tests/components/zoneminder/test_config_flow.py
deleted file mode 100644
index 279613e2b38..00000000000
--- a/tests/components/zoneminder/test_config_flow.py
+++ /dev/null
@@ -1,119 +0,0 @@
-"""Config flow tests."""
-import requests
-from zoneminder.zm import ZoneMinder
-
-from homeassistant import config_entries
-from homeassistant.components.zoneminder import ClientAvailabilityResult, const
-from homeassistant.const import (
-    CONF_HOST,
-    CONF_PASSWORD,
-    CONF_PATH,
-    CONF_SOURCE,
-    CONF_SSL,
-    CONF_USERNAME,
-    CONF_VERIFY_SSL,
-)
-from homeassistant.core import HomeAssistant
-
-from tests.async_mock import MagicMock, patch
-
-
-async def test_import(hass: HomeAssistant) -> None:
-    """Test import from configuration yaml."""
-    with patch(
-        "homeassistant.components.zoneminder.common.ZoneMinder", autospec=ZoneMinder
-    ) as zoneminder_mock:
-        conf_data = {
-            CONF_HOST: "host1",
-            CONF_USERNAME: "username1",
-            CONF_PASSWORD: "password1",
-            CONF_PATH: "path1",
-            const.CONF_PATH_ZMS: "path_zms1",
-            CONF_SSL: False,
-            CONF_VERIFY_SSL: True,
-        }
-
-        zm_client: ZoneMinder = MagicMock(spec=ZoneMinder)
-        zm_client.get_zms_url.return_value = "http://host1/path_zms1"
-        zoneminder_mock.return_value = zm_client
-
-        zm_client.login.return_value = False
-        result = await hass.config_entries.flow.async_init(
-            const.DOMAIN,
-            context={"source": config_entries.SOURCE_IMPORT},
-            data=conf_data,
-        )
-        assert result
-        assert result["type"] == "abort"
-        assert result["reason"] == "auth_fail"
-
-        zm_client.login.return_value = True
-        result = await hass.config_entries.flow.async_init(
-            const.DOMAIN,
-            context={"source": config_entries.SOURCE_IMPORT},
-            data=conf_data,
-        )
-        assert result
-        assert result["type"] == "create_entry"
-        assert result["data"] == {
-            **conf_data,
-            CONF_SOURCE: config_entries.SOURCE_IMPORT,
-        }
-
-
-async def test_user(hass: HomeAssistant) -> None:
-    """Test user initiated creation."""
-    with patch(
-        "homeassistant.components.zoneminder.common.ZoneMinder", autospec=ZoneMinder
-    ) as zoneminder_mock:
-        conf_data = {
-            CONF_HOST: "host1",
-            CONF_USERNAME: "username1",
-            CONF_PASSWORD: "password1",
-            CONF_PATH: "path1",
-            const.CONF_PATH_ZMS: "path_zms1",
-            CONF_SSL: False,
-            CONF_VERIFY_SSL: True,
-        }
-
-        result = await hass.config_entries.flow.async_init(
-            const.DOMAIN, context={"source": config_entries.SOURCE_USER}
-        )
-        assert result
-        assert result["type"] == "form"
-
-        zm_client: ZoneMinder = MagicMock(spec=ZoneMinder)
-        zoneminder_mock.return_value = zm_client
-
-        zm_client.login.side_effect = requests.exceptions.ConnectionError()
-        result = await hass.config_entries.flow.async_configure(
-            result["flow_id"],
-            conf_data,
-        )
-        assert result
-        assert result["type"] == "form"
-        assert result["errors"] == {
-            "base": ClientAvailabilityResult.ERROR_CONNECTION_ERROR.value
-        }
-
-        zm_client.login.side_effect = None
-        zm_client.login.return_value = False
-        result = await hass.config_entries.flow.async_configure(
-            result["flow_id"],
-            conf_data,
-        )
-        assert result
-        assert result["type"] == "form"
-        assert result["errors"] == {
-            "base": ClientAvailabilityResult.ERROR_AUTH_FAIL.value
-        }
-
-        zm_client.login.return_value = True
-        zm_client.get_zms_url.return_value = "http://host1/path_zms1"
-        result = await hass.config_entries.flow.async_configure(
-            result["flow_id"],
-            conf_data,
-        )
-        assert result
-        assert result["type"] == "create_entry"
-        assert result["data"] == conf_data
diff --git a/tests/components/zoneminder/test_init.py b/tests/components/zoneminder/test_init.py
deleted file mode 100644
index 333106946bd..00000000000
--- a/tests/components/zoneminder/test_init.py
+++ /dev/null
@@ -1,122 +0,0 @@
-"""Tests for init functions."""
-from datetime import timedelta
-
-from zoneminder.zm import ZoneMinder
-
-from homeassistant import config_entries
-from homeassistant.components.zoneminder import const
-from homeassistant.components.zoneminder.common import is_client_in_data
-from homeassistant.config_entries import (
-    ENTRY_STATE_LOADED,
-    ENTRY_STATE_NOT_LOADED,
-    ENTRY_STATE_SETUP_RETRY,
-)
-from homeassistant.const import (
-    ATTR_ID,
-    ATTR_NAME,
-    CONF_HOST,
-    CONF_PASSWORD,
-    CONF_PATH,
-    CONF_SOURCE,
-    CONF_SSL,
-    CONF_USERNAME,
-    CONF_VERIFY_SSL,
-)
-from homeassistant.core import HomeAssistant
-from homeassistant.setup import async_setup_component
-import homeassistant.util.dt as dt_util
-
-from tests.async_mock import MagicMock, patch
-from tests.common import async_fire_time_changed
-
-
-async def test_no_yaml_config(hass: HomeAssistant) -> None:
-    """Test empty yaml config."""
-    with patch(
-        "homeassistant.components.zoneminder.common.ZoneMinder", autospec=ZoneMinder
-    ) as zoneminder_mock:
-        zm_client: ZoneMinder = MagicMock(spec=ZoneMinder)
-        zm_client.get_zms_url.return_value = "http://host1/path_zms1"
-        zm_client.login.return_value = True
-        zm_client.get_monitors.return_value = []
-
-        zoneminder_mock.return_value = zm_client
-
-        hass_config = {const.DOMAIN: []}
-        await async_setup_component(hass, const.DOMAIN, hass_config)
-        await hass.async_block_till_done()
-        assert not hass.services.has_service(const.DOMAIN, const.SERVICE_SET_RUN_STATE)
-
-
-async def test_yaml_config_import(hass: HomeAssistant) -> None:
-    """Test yaml config import."""
-    with patch(
-        "homeassistant.components.zoneminder.common.ZoneMinder", autospec=ZoneMinder
-    ) as zoneminder_mock:
-        zm_client: ZoneMinder = MagicMock(spec=ZoneMinder)
-        zm_client.get_zms_url.return_value = "http://host1/path_zms1"
-        zm_client.login.return_value = True
-        zm_client.get_monitors.return_value = []
-
-        zoneminder_mock.return_value = zm_client
-
-        hass_config = {const.DOMAIN: [{CONF_HOST: "host1"}]}
-        await async_setup_component(hass, const.DOMAIN, hass_config)
-        await hass.async_block_till_done()
-        assert hass.services.has_service(const.DOMAIN, const.SERVICE_SET_RUN_STATE)
-
-
-async def test_load_call_service_and_unload(hass: HomeAssistant) -> None:
-    """Test config entry load/unload and calling of service."""
-    with patch(
-        "homeassistant.components.zoneminder.common.ZoneMinder", autospec=ZoneMinder
-    ) as zoneminder_mock:
-        zm_client: ZoneMinder = MagicMock(spec=ZoneMinder)
-        zm_client.get_zms_url.return_value = "http://host1/path_zms1"
-        zm_client.login.side_effect = [True, True, False, True]
-        zm_client.get_monitors.return_value = []
-        zm_client.is_available.return_value = True
-
-        zoneminder_mock.return_value = zm_client
-
-        await hass.config_entries.flow.async_init(
-            const.DOMAIN,
-            context={CONF_SOURCE: config_entries.SOURCE_USER},
-            data={
-                CONF_HOST: "host1",
-                CONF_USERNAME: "username1",
-                CONF_PASSWORD: "password1",
-                CONF_PATH: "path1",
-                const.CONF_PATH_ZMS: "path_zms1",
-                CONF_SSL: False,
-                CONF_VERIFY_SSL: True,
-            },
-        )
-        await hass.async_block_till_done()
-
-        config_entry = next(iter(hass.config_entries.async_entries(const.DOMAIN)), None)
-        assert config_entry
-
-        assert config_entry.state == ENTRY_STATE_SETUP_RETRY
-        assert not is_client_in_data(hass, "host1")
-
-        async_fire_time_changed(hass, dt_util.utcnow() + timedelta(seconds=10))
-        await hass.async_block_till_done()
-        assert config_entry.state == ENTRY_STATE_LOADED
-        assert is_client_in_data(hass, "host1")
-
-        assert hass.services.has_service(const.DOMAIN, const.SERVICE_SET_RUN_STATE)
-
-        await hass.services.async_call(
-            const.DOMAIN,
-            const.SERVICE_SET_RUN_STATE,
-            {ATTR_ID: "host1", ATTR_NAME: "away"},
-        )
-        await hass.async_block_till_done()
-        zm_client.set_active_state.assert_called_with("away")
-
-        await config_entry.async_unload(hass)
-        await hass.async_block_till_done()
-        assert config_entry.state == ENTRY_STATE_NOT_LOADED
-        assert not is_client_in_data(hass, "host1")
-        assert not hass.services.has_service(const.DOMAIN, const.SERVICE_SET_RUN_STATE)
diff --git a/tests/components/zoneminder/test_sensor.py b/tests/components/zoneminder/test_sensor.py
deleted file mode 100644
index 0b9db899387..00000000000
--- a/tests/components/zoneminder/test_sensor.py
+++ /dev/null
@@ -1,167 +0,0 @@
-"""Binary sensor tests."""
-from zoneminder.monitor import Monitor, MonitorState, TimePeriod
-from zoneminder.zm import ZoneMinder
-
-from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN
-from homeassistant.components.zoneminder import const
-from homeassistant.components.zoneminder.sensor import CONF_INCLUDE_ARCHIVED
-from homeassistant.config import async_process_ha_core_config
-from homeassistant.const import (
-    ATTR_ENTITY_ID,
-    CONF_HOST,
-    CONF_MONITORED_CONDITIONS,
-    CONF_PASSWORD,
-    CONF_PATH,
-    CONF_PLATFORM,
-    CONF_SSL,
-    CONF_USERNAME,
-    CONF_VERIFY_SSL,
-)
-from homeassistant.core import DOMAIN as HASS_DOMAIN, HomeAssistant
-from homeassistant.setup import async_setup_component
-
-from tests.async_mock import MagicMock, patch
-from tests.common import MockConfigEntry
-
-
-async def test_async_setup_entry(hass: HomeAssistant) -> None:
-    """Test setup of sensor entities."""
-
-    def _get_events(monitor_id: int, time_period: TimePeriod, include_archived: bool):
-        enum_list = [name for name in dir(TimePeriod) if not name.startswith("_")]
-        tp_index = enum_list.index(time_period.name)
-        return (100 * monitor_id) + (tp_index * 10) + include_archived
-
-    def _monitor1_get_events(time_period: TimePeriod, include_archived: bool):
-        return _get_events(1, time_period, include_archived)
-
-    def _monitor2_get_events(time_period: TimePeriod, include_archived: bool):
-        return _get_events(2, time_period, include_archived)
-
-    with patch(
-        "homeassistant.components.zoneminder.common.ZoneMinder", autospec=ZoneMinder
-    ) as zoneminder_mock:
-        monitor1 = MagicMock(spec=Monitor)
-        monitor1.name = "monitor1"
-        monitor1.mjpeg_image_url = "mjpeg_image_url1"
-        monitor1.still_image_url = "still_image_url1"
-        monitor1.is_recording = True
-        monitor1.is_available = True
-        monitor1.function = MonitorState.MONITOR
-        monitor1.get_events.side_effect = _monitor1_get_events
-
-        monitor2 = MagicMock(spec=Monitor)
-        monitor2.name = "monitor2"
-        monitor2.mjpeg_image_url = "mjpeg_image_url2"
-        monitor2.still_image_url = "still_image_url2"
-        monitor2.is_recording = False
-        monitor2.is_available = False
-        monitor2.function = MonitorState.MODECT
-        monitor2.get_events.side_effect = _monitor2_get_events
-
-        zm_client: ZoneMinder = MagicMock(spec=ZoneMinder)
-        zm_client.get_zms_url.return_value = "http://host1/path_zms1"
-        zm_client.login.return_value = True
-        zm_client.get_monitors.return_value = [monitor1, monitor2]
-
-        zoneminder_mock.return_value = zm_client
-
-        config_entry = MockConfigEntry(
-            domain=const.DOMAIN,
-            unique_id="host1",
-            data={
-                CONF_HOST: "host1",
-                CONF_USERNAME: "username1",
-                CONF_PASSWORD: "password1",
-                CONF_PATH: "path1",
-                const.CONF_PATH_ZMS: "path_zms1",
-                CONF_SSL: False,
-                CONF_VERIFY_SSL: True,
-            },
-        )
-        config_entry.add_to_hass(hass)
-
-        hass_config = {
-            HASS_DOMAIN: {},
-            SENSOR_DOMAIN: [
-                {
-                    CONF_PLATFORM: const.DOMAIN,
-                    CONF_INCLUDE_ARCHIVED: True,
-                    CONF_MONITORED_CONDITIONS: ["all", "day"],
-                }
-            ],
-        }
-
-        await async_process_ha_core_config(hass, hass_config[HASS_DOMAIN])
-        await async_setup_component(hass, HASS_DOMAIN, hass_config)
-        await async_setup_component(hass, SENSOR_DOMAIN, hass_config)
-        await hass.async_block_till_done()
-        await async_setup_component(hass, const.DOMAIN, hass_config)
-        await hass.async_block_till_done()
-
-        await hass.services.async_call(
-            HASS_DOMAIN, "update_entity", {ATTR_ENTITY_ID: "sensor.monitor1_status"}
-        )
-        await hass.services.async_call(
-            HASS_DOMAIN, "update_entity", {ATTR_ENTITY_ID: "sensor.monitor1_events"}
-        )
-        await hass.services.async_call(
-            HASS_DOMAIN,
-            "update_entity",
-            {ATTR_ENTITY_ID: "sensor.monitor1_events_last_day"},
-        )
-        await hass.services.async_call(
-            HASS_DOMAIN, "update_entity", {ATTR_ENTITY_ID: "sensor.monitor2_status"}
-        )
-        await hass.services.async_call(
-            HASS_DOMAIN, "update_entity", {ATTR_ENTITY_ID: "sensor.monitor2_events"}
-        )
-        await hass.services.async_call(
-            HASS_DOMAIN,
-            "update_entity",
-            {ATTR_ENTITY_ID: "sensor.monitor2_events_last_day"},
-        )
-        await hass.async_block_till_done()
-        assert (
-            hass.states.get("sensor.monitor1_status").state
-            == MonitorState.MONITOR.value
-        )
-        assert hass.states.get("sensor.monitor1_events").state == "101"
-        assert hass.states.get("sensor.monitor1_events_last_day").state == "111"
-        assert hass.states.get("sensor.monitor2_status").state == "unavailable"
-        assert hass.states.get("sensor.monitor2_events").state == "201"
-        assert hass.states.get("sensor.monitor2_events_last_day").state == "211"
-
-        monitor1.function = MonitorState.NONE
-        monitor2.function = MonitorState.NODECT
-        await hass.services.async_call(
-            HASS_DOMAIN, "update_entity", {ATTR_ENTITY_ID: "sensor.monitor1_status"}
-        )
-        await hass.services.async_call(
-            HASS_DOMAIN, "update_entity", {ATTR_ENTITY_ID: "sensor.monitor1_events"}
-        )
-        await hass.services.async_call(
-            HASS_DOMAIN,
-            "update_entity",
-            {ATTR_ENTITY_ID: "sensor.monitor1_events_last_day"},
-        )
-        await hass.services.async_call(
-            HASS_DOMAIN, "update_entity", {ATTR_ENTITY_ID: "sensor.monitor2_status"}
-        )
-        await hass.services.async_call(
-            HASS_DOMAIN, "update_entity", {ATTR_ENTITY_ID: "sensor.monitor2_events"}
-        )
-        await hass.services.async_call(
-            HASS_DOMAIN,
-            "update_entity",
-            {ATTR_ENTITY_ID: "sensor.monitor2_events_last_day"},
-        )
-        await hass.async_block_till_done()
-        assert (
-            hass.states.get("sensor.monitor1_status").state == MonitorState.NONE.value
-        )
-        assert hass.states.get("sensor.monitor1_events").state == "101"
-        assert hass.states.get("sensor.monitor1_events_last_day").state == "111"
-        assert hass.states.get("sensor.monitor2_status").state == "unavailable"
-        assert hass.states.get("sensor.monitor2_events").state == "201"
-        assert hass.states.get("sensor.monitor2_events_last_day").state == "211"
diff --git a/tests/components/zoneminder/test_switch.py b/tests/components/zoneminder/test_switch.py
deleted file mode 100644
index 3665b2fa17e..00000000000
--- a/tests/components/zoneminder/test_switch.py
+++ /dev/null
@@ -1,126 +0,0 @@
-"""Binary sensor tests."""
-from zoneminder.monitor import Monitor, MonitorState
-from zoneminder.zm import ZoneMinder
-
-from homeassistant.components.switch import DOMAIN as SWITCH_DOMAIN
-from homeassistant.components.zoneminder import const
-from homeassistant.config import async_process_ha_core_config
-from homeassistant.const import (
-    ATTR_ENTITY_ID,
-    CONF_COMMAND_OFF,
-    CONF_COMMAND_ON,
-    CONF_HOST,
-    CONF_PASSWORD,
-    CONF_PATH,
-    CONF_PLATFORM,
-    CONF_SSL,
-    CONF_USERNAME,
-    CONF_VERIFY_SSL,
-    STATE_OFF,
-    STATE_ON,
-)
-from homeassistant.core import DOMAIN as HASS_DOMAIN, HomeAssistant
-from homeassistant.setup import async_setup_component
-
-from tests.async_mock import MagicMock, patch
-from tests.common import MockConfigEntry
-
-
-async def test_async_setup_entry(hass: HomeAssistant) -> None:
-    """Test setup of sensor entities."""
-
-    with patch(
-        "homeassistant.components.zoneminder.common.ZoneMinder", autospec=ZoneMinder
-    ) as zoneminder_mock:
-        monitor1 = MagicMock(spec=Monitor)
-        monitor1.name = "monitor1"
-        monitor1.mjpeg_image_url = "mjpeg_image_url1"
-        monitor1.still_image_url = "still_image_url1"
-        monitor1.is_recording = True
-        monitor1.is_available = True
-        monitor1.function = MonitorState.MONITOR
-
-        monitor2 = MagicMock(spec=Monitor)
-        monitor2.name = "monitor2"
-        monitor2.mjpeg_image_url = "mjpeg_image_url2"
-        monitor2.still_image_url = "still_image_url2"
-        monitor2.is_recording = False
-        monitor2.is_available = False
-        monitor2.function = MonitorState.MODECT
-
-        zm_client: ZoneMinder = MagicMock(spec=ZoneMinder)
-        zm_client.get_zms_url.return_value = "http://host1/path_zms1"
-        zm_client.login.return_value = True
-        zm_client.get_monitors.return_value = [monitor1, monitor2]
-
-        zoneminder_mock.return_value = zm_client
-
-        config_entry = MockConfigEntry(
-            domain=const.DOMAIN,
-            unique_id="host1",
-            data={
-                CONF_HOST: "host1",
-                CONF_USERNAME: "username1",
-                CONF_PASSWORD: "password1",
-                CONF_PATH: "path1",
-                const.CONF_PATH_ZMS: "path_zms1",
-                CONF_SSL: False,
-                CONF_VERIFY_SSL: True,
-            },
-        )
-        config_entry.add_to_hass(hass)
-
-        hass_config = {
-            HASS_DOMAIN: {},
-            SWITCH_DOMAIN: [
-                {
-                    CONF_PLATFORM: const.DOMAIN,
-                    CONF_COMMAND_ON: MonitorState.MONITOR.value,
-                    CONF_COMMAND_OFF: MonitorState.MODECT.value,
-                },
-                {
-                    CONF_PLATFORM: const.DOMAIN,
-                    CONF_COMMAND_ON: MonitorState.MODECT.value,
-                    CONF_COMMAND_OFF: MonitorState.MONITOR.value,
-                },
-            ],
-        }
-
-        await async_process_ha_core_config(hass, hass_config[HASS_DOMAIN])
-        await async_setup_component(hass, HASS_DOMAIN, hass_config)
-        await async_setup_component(hass, SWITCH_DOMAIN, hass_config)
-        await hass.async_block_till_done()
-        await async_setup_component(hass, const.DOMAIN, hass_config)
-        await hass.async_block_till_done()
-
-        await hass.services.async_call(
-            SWITCH_DOMAIN, "turn_on", {ATTR_ENTITY_ID: "switch.monitor1_state"}
-        )
-        await hass.services.async_call(
-            SWITCH_DOMAIN, "turn_off", {ATTR_ENTITY_ID: "switch.monitor1_state_2"}
-        )
-        await hass.async_block_till_done()
-        assert hass.states.get("switch.monitor1_state").state == STATE_ON
-        assert hass.states.get("switch.monitor1_state_2").state == STATE_OFF
-
-        await hass.services.async_call(
-            SWITCH_DOMAIN, "turn_off", {ATTR_ENTITY_ID: "switch.monitor1_state"}
-        )
-        await hass.services.async_call(
-            SWITCH_DOMAIN, "turn_on", {ATTR_ENTITY_ID: "switch.monitor1_state_2"}
-        )
-        await hass.async_block_till_done()
-        assert hass.states.get("switch.monitor1_state").state == STATE_OFF
-        assert hass.states.get("switch.monitor1_state_2").state == STATE_ON
-
-        monitor1.function = MonitorState.NONE
-        monitor2.function = MonitorState.NODECT
-        await hass.services.async_call(
-            HASS_DOMAIN, "update_entity", {ATTR_ENTITY_ID: "switch.monitor1_state"}
-        )
-        await hass.services.async_call(
-            HASS_DOMAIN, "update_entity", {ATTR_ENTITY_ID: "switch.monitor1_state_2"}
-        )
-        await hass.async_block_till_done()
-        assert hass.states.get("switch.monitor1_state").state == STATE_OFF
-        assert hass.states.get("switch.monitor1_state_2").state == STATE_OFF

From d2077acc92b0643b47b71dd22564a2154b93313c Mon Sep 17 00:00:00 2001
From: Paulus Schoutsen <balloob@gmail.com>
Date: Wed, 7 Oct 2020 16:44:13 +0200
Subject: [PATCH 49/82] Warn when using Python 3.7 (#41400)

---
 homeassistant/const.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/homeassistant/const.py b/homeassistant/const.py
index c4f6f1c6879..69e834bff5e 100644
--- a/homeassistant/const.py
+++ b/homeassistant/const.py
@@ -7,7 +7,7 @@ __version__ = f"{__short_version__}.{PATCH_VERSION}"
 REQUIRED_PYTHON_VER = (3, 7, 1)
 # Truthy date string triggers showing related deprecation warning messages.
 REQUIRED_NEXT_PYTHON_VER = (3, 8, 0)
-REQUIRED_NEXT_PYTHON_DATE = ""
+REQUIRED_NEXT_PYTHON_DATE = "December 7, 2020"
 
 # Format for platform files
 PLATFORM_FORMAT = "{platform}.{domain}"

From cde6400482b75e8c40d1f60e6486c51bccb32bf5 Mon Sep 17 00:00:00 2001
From: Franck Nijhof <git@frenck.dev>
Date: Wed, 7 Oct 2020 17:10:04 +0200
Subject: [PATCH 50/82] Bumped version to 0.116.0

---
 homeassistant/const.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/homeassistant/const.py b/homeassistant/const.py
index 69e834bff5e..35b4b234597 100644
--- a/homeassistant/const.py
+++ b/homeassistant/const.py
@@ -1,7 +1,7 @@
 """Constants used by Home Assistant components."""
 MAJOR_VERSION = 0
 MINOR_VERSION = 116
-PATCH_VERSION = "0b6"
+PATCH_VERSION = "0"
 __short_version__ = f"{MAJOR_VERSION}.{MINOR_VERSION}"
 __version__ = f"{__short_version__}.{PATCH_VERSION}"
 REQUIRED_PYTHON_VER = (3, 7, 1)

From a3692859e90aca5242ce82d617d527b5abd89920 Mon Sep 17 00:00:00 2001
From: Khole <ktech6@outlook.com>
Date: Wed, 30 Sep 2020 23:02:42 +0100
Subject: [PATCH 51/82] Update Pyhiveapi Library Version (#40804)

* Update Pyhiveapi Library Version

This fixs an issue caused by a change in authentication method by hive

* Update Library Version
---
 homeassistant/components/hive/manifest.json | 2 +-
 requirements_all.txt                        | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/homeassistant/components/hive/manifest.json b/homeassistant/components/hive/manifest.json
index 060a1a0a200..f8fb9bc8c2a 100644
--- a/homeassistant/components/hive/manifest.json
+++ b/homeassistant/components/hive/manifest.json
@@ -2,6 +2,6 @@
   "domain": "hive",
   "name": "Hive",
   "documentation": "https://www.home-assistant.io/integrations/hive",
-  "requirements": ["pyhiveapi==0.2.20.1"],
+  "requirements": ["pyhiveapi==0.2.20.2"],
   "codeowners": ["@Rendili", "@KJonline"]
 }
diff --git a/requirements_all.txt b/requirements_all.txt
index 6aa3e39b844..b8ff2d8ea33 100644
--- a/requirements_all.txt
+++ b/requirements_all.txt
@@ -1401,7 +1401,7 @@ pyheos==0.6.0
 pyhik==0.2.7
 
 # homeassistant.components.hive
-pyhiveapi==0.2.20.1
+pyhiveapi==0.2.20.2
 
 # homeassistant.components.homematic
 pyhomematic==0.1.68

From 60fe64d1198164ffc12b3912fcb9546394f2c9e2 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Thu, 8 Oct 2020 09:09:50 -0500
Subject: [PATCH 52/82] Ensure recorder commit can retry after encountering
 invalid data (#41426)

---
 homeassistant/components/recorder/__init__.py |  3 +-
 tests/components/recorder/test_init.py        | 39 +++++++++++++++++++
 2 files changed, 41 insertions(+), 1 deletion(-)

diff --git a/homeassistant/components/recorder/__init__.py b/homeassistant/components/recorder/__init__.py
index 63d466fa4d1..9630f94d807 100644
--- a/homeassistant/components/recorder/__init__.py
+++ b/homeassistant/components/recorder/__init__.py
@@ -494,7 +494,8 @@ class Recorder(threading.Thread):
             for dbstate in self._pending_expunge:
                 # Expunge the state so its not expired
                 # until we use it later for dbstate.old_state
-                self.event_session.expunge(dbstate)
+                if dbstate in self.event_session:
+                    self.event_session.expunge(dbstate)
             self._pending_expunge = []
             self.event_session.commit()
         except Exception as err:
diff --git a/tests/components/recorder/test_init.py b/tests/components/recorder/test_init.py
index 08af027bce3..c33455c0858 100644
--- a/tests/components/recorder/test_init.py
+++ b/tests/components/recorder/test_init.py
@@ -4,6 +4,7 @@ from datetime import datetime, timedelta
 import unittest
 
 import pytest
+from sqlalchemy.exc import OperationalError
 
 from homeassistant.components.recorder import (
     CONFIG_SCHEMA,
@@ -452,3 +453,41 @@ def test_run_information(hass_recorder):
 
 class CannotSerializeMe:
     """A class that the JSONEncoder cannot serialize."""
+
+
+def test_saving_state_with_exception(hass, hass_recorder, caplog):
+    """Test saving and restoring a state."""
+    hass = hass_recorder()
+
+    entity_id = "test.recorder"
+    state = "restoring_from_db"
+    attributes = {"test_attr": 5, "test_attr_10": "nice"}
+
+    def _throw_if_state_in_session(*args, **kwargs):
+        for obj in hass.data[DATA_INSTANCE].event_session:
+            if isinstance(obj, States):
+                raise OperationalError(
+                    "insert the state", "fake params", "forced to fail"
+                )
+
+    with patch("time.sleep"), patch.object(
+        hass.data[DATA_INSTANCE].event_session,
+        "flush",
+        side_effect=_throw_if_state_in_session,
+    ):
+        hass.states.set(entity_id, "fail", attributes)
+        wait_recording_done(hass)
+
+    assert "Error executing query" in caplog.text
+    assert "Error saving events" not in caplog.text
+
+    caplog.clear()
+    hass.states.set(entity_id, state, attributes)
+    wait_recording_done(hass)
+
+    with session_scope(hass=hass) as session:
+        db_states = list(session.query(States))
+        assert len(db_states) >= 1
+
+    assert "Error executing query" not in caplog.text
+    assert "Error saving events" not in caplog.text

From 0a55f024a48952d49767a1657b9419fdcf4959ae Mon Sep 17 00:00:00 2001
From: Paulus Schoutsen <balloob@gmail.com>
Date: Thu, 8 Oct 2020 12:31:46 +0200
Subject: [PATCH 53/82] Downgrade Paho MQTT to 1.5.0 (#41479)

---
 homeassistant/components/mqtt/manifest.json | 2 +-
 homeassistant/package_constraints.txt       | 2 +-
 requirements_all.txt                        | 2 ++
 requirements_test_all.txt                   | 3 +--
 4 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/homeassistant/components/mqtt/manifest.json b/homeassistant/components/mqtt/manifest.json
index 4d44090a4e3..8b293eb06f6 100644
--- a/homeassistant/components/mqtt/manifest.json
+++ b/homeassistant/components/mqtt/manifest.json
@@ -3,7 +3,7 @@
   "name": "MQTT",
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/mqtt",
-  "requirements": ["paho-mqtt==1.5.1"],
+  "requirements": ["paho-mqtt==1.5.0"],
   "dependencies": ["http"],
   "codeowners": ["@home-assistant/core", "@emontnemery"]
 }
diff --git a/homeassistant/package_constraints.txt b/homeassistant/package_constraints.txt
index cdda546a4e1..fd250ec7661 100644
--- a/homeassistant/package_constraints.txt
+++ b/homeassistant/package_constraints.txt
@@ -17,7 +17,7 @@ home-assistant-frontend==20201001.1
 importlib-metadata==1.6.0;python_version<'3.8'
 jinja2>=2.11.2
 netdisco==2.8.2
-paho-mqtt==1.5.1
+paho-mqtt==1.5.0
 pillow==7.2.0
 pip>=8.0.3
 python-slugify==4.0.1
diff --git a/requirements_all.txt b/requirements_all.txt
index b8ff2d8ea33..e8e013bba35 100644
--- a/requirements_all.txt
+++ b/requirements_all.txt
@@ -1058,6 +1058,8 @@ orvibo==1.1.1
 ovoenergy==1.1.7
 
 # homeassistant.components.mqtt
+paho-mqtt==1.5.0
+
 # homeassistant.components.shiftr
 paho-mqtt==1.5.1
 
diff --git a/requirements_test_all.txt b/requirements_test_all.txt
index deff4c9aafc..12f7ecf4661 100644
--- a/requirements_test_all.txt
+++ b/requirements_test_all.txt
@@ -499,8 +499,7 @@ openerz-api==0.1.0
 ovoenergy==1.1.7
 
 # homeassistant.components.mqtt
-# homeassistant.components.shiftr
-paho-mqtt==1.5.1
+paho-mqtt==1.5.0
 
 # homeassistant.components.panasonic_viera
 panasonic_viera==0.3.6

From cc4d71f942697f1272f7869e9109a63531eca4cf Mon Sep 17 00:00:00 2001
From: cgtobi <cgtobi@users.noreply.github.com>
Date: Thu, 8 Oct 2020 15:08:15 +0200
Subject: [PATCH 54/82] Bump pyatmo version to 4.1.0 (#41487)

---
 homeassistant/components/netatmo/manifest.json | 2 +-
 requirements_all.txt                           | 2 +-
 requirements_test_all.txt                      | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/homeassistant/components/netatmo/manifest.json b/homeassistant/components/netatmo/manifest.json
index b7205431bb5..12c9220c361 100644
--- a/homeassistant/components/netatmo/manifest.json
+++ b/homeassistant/components/netatmo/manifest.json
@@ -3,7 +3,7 @@
   "name": "Netatmo",
   "documentation": "https://www.home-assistant.io/integrations/netatmo",
   "requirements": [
-    "pyatmo==4.0.0"
+    "pyatmo==4.1.0"
   ],
   "after_dependencies": [
     "cloud",
diff --git a/requirements_all.txt b/requirements_all.txt
index e8e013bba35..9cd48fab164 100644
--- a/requirements_all.txt
+++ b/requirements_all.txt
@@ -1252,7 +1252,7 @@ pyarlo==0.2.3
 pyatag==0.3.4.4
 
 # homeassistant.components.netatmo
-pyatmo==4.0.0
+pyatmo==4.1.0
 
 # homeassistant.components.atome
 pyatome==0.1.1
diff --git a/requirements_test_all.txt b/requirements_test_all.txt
index 12f7ecf4661..60e53a0b1b5 100644
--- a/requirements_test_all.txt
+++ b/requirements_test_all.txt
@@ -615,7 +615,7 @@ pyarlo==0.2.3
 pyatag==0.3.4.4
 
 # homeassistant.components.netatmo
-pyatmo==4.0.0
+pyatmo==4.1.0
 
 # homeassistant.components.blackbird
 pyblackbird==0.5

From 22f76a93636a32e1788249205ea4d7dab5e55028 Mon Sep 17 00:00:00 2001
From: Guido Schmitz <Shutgun@users.noreply.github.com>
Date: Thu, 8 Oct 2020 16:48:05 +0200
Subject: [PATCH 55/82] Fix async_unload_entry for devolo Home Control (#41488)

---
 .../components/devolo_home_control/__init__.py         | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/homeassistant/components/devolo_home_control/__init__.py b/homeassistant/components/devolo_home_control/__init__.py
index c955bf77096..69327f96510 100644
--- a/homeassistant/components/devolo_home_control/__init__.py
+++ b/homeassistant/components/devolo_home_control/__init__.py
@@ -1,4 +1,5 @@
 """The devolo_home_control integration."""
+import asyncio
 from functools import partial
 
 from devolo_home_control_api.homecontrol import HomeControl
@@ -71,8 +72,13 @@ async def async_setup_entry(hass: HomeAssistantType, entry: ConfigEntry) -> bool
 
 async def async_unload_entry(hass, config_entry):
     """Unload a config entry."""
-    unload = await hass.config_entries.async_forward_entry_unload(
-        config_entry, "switch"
+    unload = all(
+        await asyncio.gather(
+            *[
+                hass.config_entries.async_forward_entry_unload(config_entry, platform)
+                for platform in PLATFORMS
+            ]
+        )
     )
 
     await hass.async_add_executor_job(

From 90d88748250f016beaf7b8f480ec53ce0ffb2e0e Mon Sep 17 00:00:00 2001
From: Bram Kragten <mail@bramkragten.nl>
Date: Thu, 8 Oct 2020 16:00:34 +0200
Subject: [PATCH 56/82] Update frontend to 20201001.2 (#41491)

---
 homeassistant/components/frontend/manifest.json | 2 +-
 homeassistant/package_constraints.txt           | 2 +-
 requirements_all.txt                            | 2 +-
 requirements_test_all.txt                       | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/homeassistant/components/frontend/manifest.json b/homeassistant/components/frontend/manifest.json
index 6732f6e99c3..fd3d4a497ab 100644
--- a/homeassistant/components/frontend/manifest.json
+++ b/homeassistant/components/frontend/manifest.json
@@ -2,7 +2,7 @@
   "domain": "frontend",
   "name": "Home Assistant Frontend",
   "documentation": "https://www.home-assistant.io/integrations/frontend",
-  "requirements": ["home-assistant-frontend==20201001.1"],
+  "requirements": ["home-assistant-frontend==20201001.2"],
   "dependencies": [
     "api",
     "auth",
diff --git a/homeassistant/package_constraints.txt b/homeassistant/package_constraints.txt
index fd250ec7661..c510ded1e5f 100644
--- a/homeassistant/package_constraints.txt
+++ b/homeassistant/package_constraints.txt
@@ -13,7 +13,7 @@ defusedxml==0.6.0
 distro==1.5.0
 emoji==0.5.4
 hass-nabucasa==0.37.0
-home-assistant-frontend==20201001.1
+home-assistant-frontend==20201001.2
 importlib-metadata==1.6.0;python_version<'3.8'
 jinja2>=2.11.2
 netdisco==2.8.2
diff --git a/requirements_all.txt b/requirements_all.txt
index 9cd48fab164..c291319b2f3 100644
--- a/requirements_all.txt
+++ b/requirements_all.txt
@@ -753,7 +753,7 @@ hole==0.5.1
 holidays==0.10.3
 
 # homeassistant.components.frontend
-home-assistant-frontend==20201001.1
+home-assistant-frontend==20201001.2
 
 # homeassistant.components.zwave
 homeassistant-pyozw==0.1.10
diff --git a/requirements_test_all.txt b/requirements_test_all.txt
index 60e53a0b1b5..a977daa08e0 100644
--- a/requirements_test_all.txt
+++ b/requirements_test_all.txt
@@ -376,7 +376,7 @@ hole==0.5.1
 holidays==0.10.3
 
 # homeassistant.components.frontend
-home-assistant-frontend==20201001.1
+home-assistant-frontend==20201001.2
 
 # homeassistant.components.zwave
 homeassistant-pyozw==0.1.10

From 26ba956242abdde17c1a6bb8320b31bf90882a0e Mon Sep 17 00:00:00 2001
From: Paulus Schoutsen <balloob@gmail.com>
Date: Thu, 8 Oct 2020 15:48:36 +0000
Subject: [PATCH 57/82] Bumped version to 0.116.1

---
 homeassistant/const.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/homeassistant/const.py b/homeassistant/const.py
index 35b4b234597..bbf942c94d3 100644
--- a/homeassistant/const.py
+++ b/homeassistant/const.py
@@ -1,7 +1,7 @@
 """Constants used by Home Assistant components."""
 MAJOR_VERSION = 0
 MINOR_VERSION = 116
-PATCH_VERSION = "0"
+PATCH_VERSION = "1"
 __short_version__ = f"{MAJOR_VERSION}.{MINOR_VERSION}"
 __version__ = f"{__short_version__}.{PATCH_VERSION}"
 REQUIRED_PYTHON_VER = (3, 7, 1)

From 3a1ee2f654f6d19dd44943c8c4601a8ac09e184b Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Thu, 8 Oct 2020 10:58:52 -0500
Subject: [PATCH 58/82] Add missing on states to media player groups (#41496)

---
 homeassistant/components/media_player/group.py | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/homeassistant/components/media_player/group.py b/homeassistant/components/media_player/group.py
index b612165fa19..6ecf90fc0a1 100644
--- a/homeassistant/components/media_player/group.py
+++ b/homeassistant/components/media_player/group.py
@@ -2,16 +2,22 @@
 
 
 from homeassistant.components.group import GroupIntegrationRegistry
-from homeassistant.const import STATE_OFF
+from homeassistant.const import (
+    STATE_IDLE,
+    STATE_OFF,
+    STATE_ON,
+    STATE_PAUSED,
+    STATE_PLAYING,
+)
 from homeassistant.core import callback
 from homeassistant.helpers.typing import HomeAssistantType
 
-from . import STATE_IDLE, STATE_PLAYING
-
 
 @callback
 def async_describe_on_off_states(
     hass: HomeAssistantType, registry: GroupIntegrationRegistry
 ) -> None:
     """Describe group on off states."""
-    registry.on_off_states({STATE_PLAYING, STATE_IDLE}, STATE_OFF)
+    registry.on_off_states(
+        {STATE_ON, STATE_PAUSED, STATE_PLAYING, STATE_IDLE}, STATE_OFF
+    )

From 22bef1d0d35de54da1f41be1acecdce13bc92442 Mon Sep 17 00:00:00 2001
From: cgtobi <cgtobi@users.noreply.github.com>
Date: Fri, 9 Oct 2020 08:37:56 +0200
Subject: [PATCH 59/82] Fix Netatmo non specified sensor types (#41517)

---
 homeassistant/components/netatmo/sensor.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/homeassistant/components/netatmo/sensor.py b/homeassistant/components/netatmo/sensor.py
index af41e01c7df..f0664daf1f8 100644
--- a/homeassistant/components/netatmo/sensor.py
+++ b/homeassistant/components/netatmo/sensor.py
@@ -136,6 +136,7 @@ async def async_setup_entry(hass, entry, async_add_entities):
             conditions = [
                 c.lower()
                 for c in data_class.get_monitored_conditions(module_id=module["_id"])
+                if c in SENSOR_TYPES
             ]
             for condition in conditions:
                 if f"{condition}_value" in SENSOR_TYPES:

From cca259422573a1eff113e2826f9cfc64f9d8bb1d Mon Sep 17 00:00:00 2001
From: Arjan van Balken <vanbalken@users.noreply.github.com>
Date: Thu, 8 Oct 2020 19:08:20 +0200
Subject: [PATCH 60/82] Update Arris TG2492LG dependency version (#41465)

---
 homeassistant/components/arris_tg2492lg/manifest.json | 2 +-
 requirements_all.txt                                  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/homeassistant/components/arris_tg2492lg/manifest.json b/homeassistant/components/arris_tg2492lg/manifest.json
index 385bb955627..2d27824ba63 100644
--- a/homeassistant/components/arris_tg2492lg/manifest.json
+++ b/homeassistant/components/arris_tg2492lg/manifest.json
@@ -3,7 +3,7 @@
   "name": "Arris TG2492LG",
   "documentation": "https://www.home-assistant.io/integrations/arris_tg2492lg",
   "requirements": [
-    "arris-tg2492lg==1.0.0"
+    "arris-tg2492lg==1.1.0"
   ],
   "codeowners": [
     "@vanbalken"
diff --git a/requirements_all.txt b/requirements_all.txt
index c291319b2f3..5b03c56d938 100644
--- a/requirements_all.txt
+++ b/requirements_all.txt
@@ -275,7 +275,7 @@ aqualogic==1.0
 arcam-fmj==0.5.3
 
 # homeassistant.components.arris_tg2492lg
-arris-tg2492lg==1.0.0
+arris-tg2492lg==1.1.0
 
 # homeassistant.components.ampio
 asmog==0.0.6

From 7cdbbc248fbb558d0b0c1c082995d18aff88c985 Mon Sep 17 00:00:00 2001
From: djtimca <60706061+djtimca@users.noreply.github.com>
Date: Thu, 8 Oct 2020 17:48:54 -0400
Subject: [PATCH 61/82] Fix omnilogic temperature sensor with metric setting
 (#41509)

---
 homeassistant/components/omnilogic/sensor.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/homeassistant/components/omnilogic/sensor.py b/homeassistant/components/omnilogic/sensor.py
index f4bb0f45d5e..e3324cfabc3 100644
--- a/homeassistant/components/omnilogic/sensor.py
+++ b/homeassistant/components/omnilogic/sensor.py
@@ -119,7 +119,7 @@ class OmniLogicTemperatureSensor(OmnilogicSensor):
         state = sensor_data
 
         if self._unit_type == "Metric":
-            hayward_state = round((hayward_state - 32) * 5 / 9, 1)
+            hayward_state = round((int(hayward_state) - 32) * 5 / 9, 1)
             hayward_unit_of_measure = TEMP_CELSIUS
 
         if int(sensor_data) == -1:

From 56436e63870ca8dfea8c0e20d4d310a062b9667a Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Fri, 9 Oct 2020 01:37:27 -0500
Subject: [PATCH 62/82] Restore group support to plant entities (#41519)

---
 homeassistant/components/plant/group.py | 15 ++++++
 tests/components/group/test_init.py     | 63 +++++++++++++++++++++++++
 2 files changed, 78 insertions(+)
 create mode 100644 homeassistant/components/plant/group.py

diff --git a/homeassistant/components/plant/group.py b/homeassistant/components/plant/group.py
new file mode 100644
index 00000000000..5d6edfa2b9a
--- /dev/null
+++ b/homeassistant/components/plant/group.py
@@ -0,0 +1,15 @@
+"""Describe group states."""
+
+
+from homeassistant.components.group import GroupIntegrationRegistry
+from homeassistant.const import STATE_OK, STATE_PROBLEM
+from homeassistant.core import callback
+from homeassistant.helpers.typing import HomeAssistantType
+
+
+@callback
+def async_describe_on_off_states(
+    hass: HomeAssistantType, registry: GroupIntegrationRegistry
+) -> None:
+    """Describe group on off states."""
+    registry.on_off_states({STATE_PROBLEM}, STATE_OK)
diff --git a/tests/components/group/test_init.py b/tests/components/group/test_init.py
index 18d37267334..5006461d32c 100644
--- a/tests/components/group/test_init.py
+++ b/tests/components/group/test_init.py
@@ -1213,3 +1213,66 @@ async def test_group_that_references_two_types_of_groups(hass):
     assert hass.states.get("group.covers").state == "closed"
     assert hass.states.get("group.device_trackers").state == "home"
     assert hass.states.get("group.grouped_group").state == "on"
+
+
+async def test_plant_group(hass):
+    """Test plant states can be grouped."""
+
+    entity_ids = [
+        "plant.upstairs",
+        "plant.downstairs",
+    ]
+
+    assert await async_setup_component(
+        hass,
+        "plant",
+        {
+            "plant": {
+                "plantname": {
+                    "sensors": {
+                        "moisture": "sensor.mqtt_plant_moisture",
+                        "battery": "sensor.mqtt_plant_battery",
+                        "temperature": "sensor.mqtt_plant_temperature",
+                        "conductivity": "sensor.mqtt_plant_conductivity",
+                        "brightness": "sensor.mqtt_plant_brightness",
+                    },
+                    "min_moisture": 20,
+                    "max_moisture": 60,
+                    "min_battery": 17,
+                    "min_conductivity": 500,
+                    "min_temperature": 15,
+                    "min_brightness": 500,
+                }
+            }
+        },
+    )
+    assert await async_setup_component(
+        hass,
+        "group",
+        {
+            "group": {
+                "plants": {"entities": entity_ids},
+                "plant_with_binary_sensors": {
+                    "entities": [*entity_ids, "binary_sensor.planter"]
+                },
+            }
+        },
+    )
+    await hass.async_block_till_done()
+
+    hass.states.async_set("binary_sensor.planter", "off")
+    for entity_id in entity_ids:
+        hass.states.async_set(entity_id, "ok")
+    await hass.async_block_till_done()
+    await hass.async_block_till_done()
+
+    assert hass.states.get("group.plants").state == "ok"
+    assert hass.states.get("group.plant_with_binary_sensors").state == "off"
+
+    hass.states.async_set("binary_sensor.planter", "on")
+    for entity_id in entity_ids:
+        hass.states.async_set(entity_id, "problem")
+
+    await hass.async_block_till_done()
+    assert hass.states.get("group.plants").state == "problem"
+    assert hass.states.get("group.plant_with_binary_sensors").state == "on"

From 72b95f7529b918cf320471c8b0a608d6a0509bb3 Mon Sep 17 00:00:00 2001
From: Xiaonan Shen <s@sxn.dev>
Date: Fri, 9 Oct 2020 19:30:42 +0800
Subject: [PATCH 63/82] Bump yeelight to 0.5.4 (#41524)

---
 homeassistant/components/yeelight/light.py      | 4 ++--
 homeassistant/components/yeelight/manifest.json | 2 +-
 requirements_all.txt                            | 2 +-
 requirements_test_all.txt                       | 2 +-
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/homeassistant/components/yeelight/light.py b/homeassistant/components/yeelight/light.py
index a84ebebf6e3..93dbc5bcb07 100644
--- a/homeassistant/components/yeelight/light.py
+++ b/homeassistant/components/yeelight/light.py
@@ -137,7 +137,7 @@ EFFECTS_MAP = {
     EFFECT_POLICE2: yee_transitions.police2,
     EFFECT_CHRISTMAS: yee_transitions.christmas,
     EFFECT_RGB: yee_transitions.rgb,
-    EFFECT_RANDOM_LOOP: yee_transitions.randomloop,
+    EFFECT_RANDOM_LOOP: yee_transitions.random_loop,
     EFFECT_LSD: yee_transitions.lsd,
     EFFECT_SLOWDOWN: yee_transitions.slowdown,
 }
@@ -661,7 +661,7 @@ class YeelightGenericLight(YeelightEntity, LightEntity):
         elif effect in EFFECTS_MAP:
             flow = Flow(count=0, transitions=EFFECTS_MAP[effect]())
         elif effect == EFFECT_FAST_RANDOM_LOOP:
-            flow = Flow(count=0, transitions=yee_transitions.randomloop(duration=250))
+            flow = Flow(count=0, transitions=yee_transitions.random_loop(duration=250))
         elif effect == EFFECT_WHATSAPP:
             flow = Flow(count=2, transitions=yee_transitions.pulse(37, 211, 102))
         elif effect == EFFECT_FACEBOOK:
diff --git a/homeassistant/components/yeelight/manifest.json b/homeassistant/components/yeelight/manifest.json
index 1e8c0472fdd..3c708d57560 100644
--- a/homeassistant/components/yeelight/manifest.json
+++ b/homeassistant/components/yeelight/manifest.json
@@ -3,7 +3,7 @@
   "name": "Yeelight",
   "documentation": "https://www.home-assistant.io/integrations/yeelight",
   "requirements": [
-    "yeelight==0.5.3"
+    "yeelight==0.5.4"
   ],
   "codeowners": [
     "@rytilahti",
diff --git a/requirements_all.txt b/requirements_all.txt
index 5b03c56d938..d6f490ff1ee 100644
--- a/requirements_all.txt
+++ b/requirements_all.txt
@@ -2295,7 +2295,7 @@ xs1-api-client==3.0.0
 yalesmartalarmclient==0.1.6
 
 # homeassistant.components.yeelight
-yeelight==0.5.3
+yeelight==0.5.4
 
 # homeassistant.components.yeelightsunflower
 yeelightsunflower==0.0.10
diff --git a/requirements_test_all.txt b/requirements_test_all.txt
index a977daa08e0..3b1b13fa1a8 100644
--- a/requirements_test_all.txt
+++ b/requirements_test_all.txt
@@ -1064,7 +1064,7 @@ wolf_smartset==0.1.6
 xmltodict==0.12.0
 
 # homeassistant.components.yeelight
-yeelight==0.5.3
+yeelight==0.5.4
 
 # homeassistant.components.zeroconf
 zeroconf==0.28.5

From dae2117078c6a3d80c0033267b0add6886366857 Mon Sep 17 00:00:00 2001
From: Maciej Bieniek <bieniu@users.noreply.github.com>
Date: Fri, 9 Oct 2020 11:16:16 +0200
Subject: [PATCH 64/82] Fix description reference in PoolSense config flow
 (#41535)

---
 homeassistant/components/poolsense/strings.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/homeassistant/components/poolsense/strings.json b/homeassistant/components/poolsense/strings.json
index d26a44cc275..71b30e0bf77 100644
--- a/homeassistant/components/poolsense/strings.json
+++ b/homeassistant/components/poolsense/strings.json
@@ -3,7 +3,7 @@
     "step": {
       "user": {
         "title": "PoolSense",
-        "description": "[%key:common::config_flow::description%]",
+        "description": "[%key:common::config_flow::description::confirm_setup%]",
         "data": {
           "email": "[%key:common::config_flow::data::email%]",
           "password": "[%key:common::config_flow::data::password%]"

From c9d53dec8d3d1ffad5a78a4cd5db55ea6ef2b3d2 Mon Sep 17 00:00:00 2001
From: cgtobi <cgtobi@users.noreply.github.com>
Date: Fri, 9 Oct 2020 12:34:52 +0200
Subject: [PATCH 65/82] Fix missing weather sensors (#41540)

---
 homeassistant/components/netatmo/sensor.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/homeassistant/components/netatmo/sensor.py b/homeassistant/components/netatmo/sensor.py
index f0664daf1f8..e20ce91d844 100644
--- a/homeassistant/components/netatmo/sensor.py
+++ b/homeassistant/components/netatmo/sensor.py
@@ -136,7 +136,7 @@ async def async_setup_entry(hass, entry, async_add_entities):
             conditions = [
                 c.lower()
                 for c in data_class.get_monitored_conditions(module_id=module["_id"])
-                if c in SENSOR_TYPES
+                if c.lower() in SENSOR_TYPES
             ]
             for condition in conditions:
                 if f"{condition}_value" in SENSOR_TYPES:

From a26413c9897c654e4a8b77ec8db61ace6e95d487 Mon Sep 17 00:00:00 2001
From: Paulus Schoutsen <balloob@gmail.com>
Date: Fri, 9 Oct 2020 13:44:04 +0000
Subject: [PATCH 66/82] Bumped version to 0.116.2

---
 homeassistant/const.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/homeassistant/const.py b/homeassistant/const.py
index bbf942c94d3..0acd31bc30a 100644
--- a/homeassistant/const.py
+++ b/homeassistant/const.py
@@ -1,7 +1,7 @@
 """Constants used by Home Assistant components."""
 MAJOR_VERSION = 0
 MINOR_VERSION = 116
-PATCH_VERSION = "1"
+PATCH_VERSION = "2"
 __short_version__ = f"{MAJOR_VERSION}.{MINOR_VERSION}"
 __version__ = f"{__short_version__}.{PATCH_VERSION}"
 REQUIRED_PYTHON_VER = (3, 7, 1)

From e072d8b6945867e5c6daffff39bcc0679ecbf4de Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Joakim=20S=C3=B8rensen?= <joasoe@gmail.com>
Date: Thu, 8 Oct 2020 20:40:45 +0200
Subject: [PATCH 67/82] Add delete to hassio API (#41500)

---
 homeassistant/components/hassio/http.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/homeassistant/components/hassio/http.py b/homeassistant/components/hassio/http.py
index 95f861e6097..e42a7378b3c 100644
--- a/homeassistant/components/hassio/http.py
+++ b/homeassistant/components/hassio/http.py
@@ -65,6 +65,7 @@ class HassIOView(HomeAssistantView):
 
         return await self._command_proxy(path, request)
 
+    delete = _handle
     get = _handle
     post = _handle
 

From 897340b11537ed97130843f9f4f326d2c7bc01d5 Mon Sep 17 00:00:00 2001
From: Quentame <polletquentin74@me.com>
Date: Mon, 12 Oct 2020 16:47:05 +0200
Subject: [PATCH 68/82] Fix disabled Synology DSM camera (#41686)

---
 homeassistant/components/synology_dsm/camera.py | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/homeassistant/components/synology_dsm/camera.py b/homeassistant/components/synology_dsm/camera.py
index 80e6802e443..1dfd8ff945b 100644
--- a/homeassistant/components/synology_dsm/camera.py
+++ b/homeassistant/components/synology_dsm/camera.py
@@ -2,12 +2,13 @@
 from typing import Dict
 
 from synology_dsm.api.surveillance_station import SynoSurveillanceStation
+from synology_dsm.api.surveillance_station.camera import SynoCamera
 
 from homeassistant.components.camera import SUPPORT_STREAM, Camera
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.helpers.typing import HomeAssistantType
 
-from . import SynologyDSMEntity
+from . import SynoApi, SynologyDSMEntity
 from .const import (
     DOMAIN,
     ENTITY_CLASS,
@@ -40,7 +41,7 @@ async def async_setup_entry(
 class SynoDSMCamera(SynologyDSMEntity, Camera):
     """Representation a Synology camera."""
 
-    def __init__(self, api, camera):
+    def __init__(self, api: SynoApi, camera: SynoCamera):
         """Initialize a Synology camera."""
         super().__init__(
             api,
@@ -69,6 +70,11 @@ class SynoDSMCamera(SynologyDSMEntity, Camera):
             ),
         }
 
+    @property
+    def available(self) -> bool:
+        """Return the availability of the camera."""
+        return self._camera.is_enabled
+
     @property
     def supported_features(self) -> int:
         """Return supported features of this camera."""
@@ -86,10 +92,14 @@ class SynoDSMCamera(SynologyDSMEntity, Camera):
 
     def camera_image(self) -> bytes:
         """Return bytes of camera image."""
+        if not self.available:
+            return None
         return self._api.surveillance_station.get_camera_image(self._camera.id)
 
     async def stream_source(self) -> str:
         """Return the source of the stream."""
+        if not self.available:
+            return None
         return self._camera.live_view.rtsp
 
     def enable_motion_detection(self):

From 42c9776c97ad8649a59ebd457ab70ef9b50ab275 Mon Sep 17 00:00:00 2001
From: Bas Nijholt <bas@nijho.lt>
Date: Tue, 13 Oct 2020 20:13:48 +0200
Subject: [PATCH 69/82] Fix KEF LSX becoming unavailable (#41700)

* Do not use asyncio.gather because the speaker only allows one concurrent connection

* bump to aiokef=0.2.16
---
 homeassistant/components/kef/manifest.json   |  2 +-
 homeassistant/components/kef/media_player.py | 26 +++++++++++---------
 requirements_all.txt                         |  2 +-
 3 files changed, 16 insertions(+), 14 deletions(-)

diff --git a/homeassistant/components/kef/manifest.json b/homeassistant/components/kef/manifest.json
index 496d7bae0f2..7441b599063 100644
--- a/homeassistant/components/kef/manifest.json
+++ b/homeassistant/components/kef/manifest.json
@@ -3,5 +3,5 @@
   "name": "KEF",
   "documentation": "https://www.home-assistant.io/integrations/kef",
   "codeowners": ["@basnijholt"],
-  "requirements": ["aiokef==0.2.13", "getmac==0.8.2"]
+  "requirements": ["aiokef==0.2.16", "getmac==0.8.2"]
 }
diff --git a/homeassistant/components/kef/media_player.py b/homeassistant/components/kef/media_player.py
index d033592cb3f..892bb0adac0 100644
--- a/homeassistant/components/kef/media_player.py
+++ b/homeassistant/components/kef/media_player.py
@@ -1,6 +1,5 @@
 """Platform for the KEF Wireless Speakers."""
 
-import asyncio
 from datetime import timedelta
 from functools import partial
 import ipaddress
@@ -164,7 +163,11 @@ async def async_setup_platform(hass, config, async_add_entities, discovery_info=
         dtype = type(options[0])  # int or float
         platform.async_register_entity_service(
             name,
-            {vol.Required(option): vol.All(vol.Coerce(dtype), vol.In(options))},
+            {
+                vol.Required(option): vol.All(
+                    vol.Coerce(float), vol.Coerce(dtype), vol.In(options)
+                )
+            },
             f"set_{which}",
         )
 
@@ -365,17 +368,16 @@ class KefMediaPlayer(MediaPlayerEntity):
             # The LSX is able to respond when off the LS50 has to be on.
             return
 
-        (mode, *rest) = await asyncio.gather(
-            self._speaker.get_mode(),
-            self._speaker.get_desk_db(),
-            self._speaker.get_wall_db(),
-            self._speaker.get_treble_db(),
-            self._speaker.get_high_hz(),
-            self._speaker.get_low_hz(),
-            self._speaker.get_sub_db(),
+        mode = await self._speaker.get_mode()
+        self._dsp = dict(
+            desk_db=await self._speaker.get_desk_db(),
+            wall_db=await self._speaker.get_wall_db(),
+            treble_db=await self._speaker.get_treble_db(),
+            high_hz=await self._speaker.get_high_hz(),
+            low_hz=await self._speaker.get_low_hz(),
+            sub_db=await self._speaker.get_sub_db(),
+            **mode._asdict(),
         )
-        keys = ["desk_db", "wall_db", "treble_db", "high_hz", "low_hz", "sub_db"]
-        self._dsp = dict(zip(keys, rest), **mode._asdict())
 
     async def async_added_to_hass(self):
         """Subscribe to DSP updates."""
diff --git a/requirements_all.txt b/requirements_all.txt
index d6f490ff1ee..003e87213bc 100644
--- a/requirements_all.txt
+++ b/requirements_all.txt
@@ -194,7 +194,7 @@ aioimaplib==0.7.15
 aiokafka==0.6.0
 
 # homeassistant.components.kef
-aiokef==0.2.13
+aiokef==0.2.16
 
 # homeassistant.components.lifx
 aiolifx==0.6.7

From b541b08d2d54dd9a8a60ba6f477d83ce47114aa3 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Mon, 12 Oct 2020 09:38:24 -0500
Subject: [PATCH 70/82] Ensure all template errors are caught and the websocket
 api reports them (#41719)

---
 .../components/websocket_api/commands.py      | 21 +++++++----
 homeassistant/exceptions.py                   |  4 +--
 homeassistant/helpers/template.py             |  2 +-
 .../components/websocket_api/test_commands.py | 35 +++++++++++++++++++
 tests/helpers/test_template.py                | 10 ++++++
 5 files changed, 61 insertions(+), 11 deletions(-)

diff --git a/homeassistant/components/websocket_api/commands.py b/homeassistant/components/websocket_api/commands.py
index 11d97f58f50..2106e745351 100644
--- a/homeassistant/components/websocket_api/commands.py
+++ b/homeassistant/components/websocket_api/commands.py
@@ -257,13 +257,20 @@ async def handle_render_template(hass, connection, msg):
     timeout = msg.get("timeout")
     info = None
 
-    if timeout and await template.async_render_will_timeout(timeout):
-        connection.send_error(
-            msg["id"],
-            const.ERR_TEMPLATE_ERROR,
-            f"Exceeded maximum execution time of {timeout}s",
-        )
-        return
+    if timeout:
+        try:
+            timed_out = await template.async_render_will_timeout(timeout)
+        except TemplateError as ex:
+            connection.send_error(msg["id"], const.ERR_TEMPLATE_ERROR, str(ex))
+            return
+
+        if timed_out:
+            connection.send_error(
+                msg["id"],
+                const.ERR_TEMPLATE_ERROR,
+                f"Exceeded maximum execution time of {timeout}s",
+            )
+            return
 
     @callback
     def _template_listener(event, updates):
diff --git a/homeassistant/exceptions.py b/homeassistant/exceptions.py
index 44587fec043..015e81f2ca0 100644
--- a/homeassistant/exceptions.py
+++ b/homeassistant/exceptions.py
@@ -1,8 +1,6 @@
 """The exceptions used by Home Assistant."""
 from typing import TYPE_CHECKING, Optional
 
-import jinja2
-
 if TYPE_CHECKING:
     from .core import Context  # noqa: F401 pylint: disable=unused-import
 
@@ -22,7 +20,7 @@ class NoEntitySpecifiedError(HomeAssistantError):
 class TemplateError(HomeAssistantError):
     """Error during template rendering."""
 
-    def __init__(self, exception: jinja2.TemplateError) -> None:
+    def __init__(self, exception: Exception) -> None:
         """Init the error."""
         super().__init__(f"{exception.__class__.__name__}: {exception}")
 
diff --git a/homeassistant/helpers/template.py b/homeassistant/helpers/template.py
index 9c849bee22e..85458cf564b 100644
--- a/homeassistant/helpers/template.py
+++ b/homeassistant/helpers/template.py
@@ -330,7 +330,7 @@ class Template:
 
         try:
             return compiled.render(kwargs).strip()
-        except jinja2.TemplateError as err:
+        except Exception as err:  # pylint: disable=broad-except
             raise TemplateError(err) from err
 
     async def async_render_will_timeout(
diff --git a/tests/components/websocket_api/test_commands.py b/tests/components/websocket_api/test_commands.py
index 3969ff90706..5c9aaf09c9e 100644
--- a/tests/components/websocket_api/test_commands.py
+++ b/tests/components/websocket_api/test_commands.py
@@ -488,6 +488,41 @@ async def test_render_template_with_error(hass, websocket_client, caplog):
     assert "TemplateError" not in caplog.text
 
 
+async def test_render_template_with_timeout_and_error(hass, websocket_client, caplog):
+    """Test a template with an error with a timeout."""
+    await websocket_client.send_json(
+        {
+            "id": 5,
+            "type": "render_template",
+            "template": "{{ now() | rando }}",
+            "timeout": 5,
+        }
+    )
+
+    msg = await websocket_client.receive_json()
+    assert msg["id"] == 5
+    assert msg["type"] == const.TYPE_RESULT
+    assert not msg["success"]
+    assert msg["error"]["code"] == const.ERR_TEMPLATE_ERROR
+
+    assert "TemplateError" not in caplog.text
+
+
+async def test_render_template_error_in_template_code(hass, websocket_client, caplog):
+    """Test a template that will throw in template.py."""
+    await websocket_client.send_json(
+        {"id": 5, "type": "render_template", "template": "{{ now() | random }}"}
+    )
+
+    msg = await websocket_client.receive_json()
+    assert msg["id"] == 5
+    assert msg["type"] == const.TYPE_RESULT
+    assert not msg["success"]
+    assert msg["error"]["code"] == const.ERR_TEMPLATE_ERROR
+
+    assert "TemplateError" not in caplog.text
+
+
 async def test_render_template_with_delayed_error(hass, websocket_client, caplog):
     """Test a template with an error that only happens after a state change."""
     hass.states.async_set("sensor.test", "on")
diff --git a/tests/helpers/test_template.py b/tests/helpers/test_template.py
index 5535fa53993..9a0b7c60ea0 100644
--- a/tests/helpers/test_template.py
+++ b/tests/helpers/test_template.py
@@ -2539,6 +2539,16 @@ async def test_lights(hass):
         assert f"sensor{i}" in info.result()
 
 
+async def test_template_errors(hass):
+    """Test template rendering wraps exceptions with TemplateError."""
+
+    with pytest.raises(TemplateError):
+        template.Template("{{ now() | rando }}", hass).async_render()
+
+    with pytest.raises(TemplateError):
+        template.Template("{{ now() | random }}", hass).async_render()
+
+
 async def test_state_attributes(hass):
     """Test state attributes."""
     hass.states.async_set("sensor.test", "23")

From fd79c141b21ab0be09a9ef092f57368bac52c291 Mon Sep 17 00:00:00 2001
From: Pascal Vizeli <pvizeli@syshack.ch>
Date: Tue, 13 Oct 2020 11:56:28 +0200
Subject: [PATCH 71/82] Offload dockermachines into core (#41756)

---
 azure-pipelines-release.yml |  4 +--
 machine/intel-nuc           | 34 +++++++++++++++++++++
 machine/odroid-c2           | 34 +++++++++++++++++++++
 machine/odroid-n2           | 34 +++++++++++++++++++++
 machine/odroid-xu           | 34 +++++++++++++++++++++
 machine/qemuarm             | 33 ++++++++++++++++++++
 machine/qemuarm-64          | 33 ++++++++++++++++++++
 machine/qemux86             | 33 ++++++++++++++++++++
 machine/qemux86-64          | 33 ++++++++++++++++++++
 machine/raspberrypi         | 61 +++++++++++++++++++++++++++++++++++++
 machine/raspberrypi2        | 61 +++++++++++++++++++++++++++++++++++++
 machine/raspberrypi3        | 61 +++++++++++++++++++++++++++++++++++++
 machine/raspberrypi3-64     | 61 +++++++++++++++++++++++++++++++++++++
 machine/raspberrypi4        | 61 +++++++++++++++++++++++++++++++++++++
 machine/raspberrypi4-64     | 61 +++++++++++++++++++++++++++++++++++++
 machine/tinker              | 48 +++++++++++++++++++++++++++++
 16 files changed, 684 insertions(+), 2 deletions(-)
 create mode 100644 machine/intel-nuc
 create mode 100644 machine/odroid-c2
 create mode 100644 machine/odroid-n2
 create mode 100644 machine/odroid-xu
 create mode 100644 machine/qemuarm
 create mode 100644 machine/qemuarm-64
 create mode 100644 machine/qemux86
 create mode 100644 machine/qemux86-64
 create mode 100644 machine/raspberrypi
 create mode 100644 machine/raspberrypi2
 create mode 100644 machine/raspberrypi3
 create mode 100644 machine/raspberrypi3-64
 create mode 100644 machine/raspberrypi4
 create mode 100644 machine/raspberrypi4-64
 create mode 100644 machine/tinker

diff --git a/azure-pipelines-release.yml b/azure-pipelines-release.yml
index 7bf8e3ddfb2..6bca099d9ad 100644
--- a/azure-pipelines-release.yml
+++ b/azure-pipelines-release.yml
@@ -115,10 +115,10 @@ stages:
         docker run --rm --privileged \
           -v ~/.docker:/root/.docker \
           -v /run/docker.sock:/run/docker.sock:rw \
+          -v $(pwd):/data:ro \
           homeassistant/amd64-builder:$(versionBuilder) \
           --homeassistant-machine "$(homeassistantRelease)=$(buildMachine)" \
-          -r https://github.com/home-assistant/hassio-homeassistant \
-          -t machine --docker-hub homeassistant
+          -t /data --docker-hub homeassistant
       displayName: 'Build Release'
 
 - stage: 'Publish'
diff --git a/machine/intel-nuc b/machine/intel-nuc
new file mode 100644
index 00000000000..4c83228387d
--- /dev/null
+++ b/machine/intel-nuc
@@ -0,0 +1,34 @@
+ARG BUILD_VERSION
+FROM homeassistant/amd64-homeassistant:$BUILD_VERSION
+
+RUN apk --no-cache add \
+    libva-intel-driver \
+    usbutils
+
+##
+# Build libcec for HDMI-CEC
+ARG LIBCEC_VERSION=6.0.2
+RUN apk add --no-cache \
+        eudev-libs \
+        p8-platform \
+    && apk add --no-cache --virtual .build-dependencies \
+        build-base \
+        cmake \
+        eudev-dev \
+        swig \
+        p8-platform-dev \
+        linux-headers \
+    && git clone --depth 1 -b libcec-${LIBCEC_VERSION} https://github.com/Pulse-Eight/libcec /usr/src/libcec \
+    && cd /usr/src/libcec \
+    && mkdir -p /usr/src/libcec/build \
+    && cd /usr/src/libcec/build \
+    && cmake -DCMAKE_INSTALL_PREFIX:PATH=/usr/local \
+        -DPYTHON_LIBRARY="/usr/local/lib/libpython3.8.so" \
+        -DPYTHON_INCLUDE_DIR="/usr/local/include/python3.8" \
+        -DHAVE_LINUX_API=1 \
+        .. \
+    && make -j$(nproc) \
+    && make install \
+    && echo "cec" > "/usr/local/lib/python3.8/site-packages/cec.pth" \
+    && apk del .build-dependencies \
+    && rm -rf /usr/src/libcec*
diff --git a/machine/odroid-c2 b/machine/odroid-c2
new file mode 100644
index 00000000000..9bfbb931ed0
--- /dev/null
+++ b/machine/odroid-c2
@@ -0,0 +1,34 @@
+ARG BUILD_VERSION
+FROM homeassistant/aarch64-homeassistant:$BUILD_VERSION
+
+RUN apk --no-cache add \
+    usbutils
+
+##
+# Build libcec for HDMI-CEC
+ARG LIBCEC_VERSION=6.0.2
+RUN apk add --no-cache \
+        eudev-libs \
+        p8-platform \
+    && apk add --no-cache --virtual .build-dependencies \
+        build-base \
+        cmake \
+        eudev-dev \
+        swig \
+        p8-platform-dev \
+        linux-headers \
+    && git clone --depth 1 -b libcec-${LIBCEC_VERSION} https://github.com/Pulse-Eight/libcec /usr/src/libcec \
+    && cd /usr/src/libcec \
+    && mkdir -p /usr/src/libcec/build \
+    && cd /usr/src/libcec/build \
+    && cmake -DCMAKE_INSTALL_PREFIX:PATH=/usr/local \
+        -DPYTHON_LIBRARY="/usr/local/lib/libpython3.8.so" \
+        -DPYTHON_INCLUDE_DIR="/usr/local/include/python3.8" \
+        -DHAVE_LINUX_API=1 \
+        -DHAVE_AOCEC_API=1 \
+        .. \
+    && make -j$(nproc) \
+    && make install \
+    && echo "cec" > "/usr/local/lib/python3.8/site-packages/cec.pth" \
+    && apk del .build-dependencies \
+    && rm -rf /usr/src/libcec*
diff --git a/machine/odroid-n2 b/machine/odroid-n2
new file mode 100644
index 00000000000..9bfbb931ed0
--- /dev/null
+++ b/machine/odroid-n2
@@ -0,0 +1,34 @@
+ARG BUILD_VERSION
+FROM homeassistant/aarch64-homeassistant:$BUILD_VERSION
+
+RUN apk --no-cache add \
+    usbutils
+
+##
+# Build libcec for HDMI-CEC
+ARG LIBCEC_VERSION=6.0.2
+RUN apk add --no-cache \
+        eudev-libs \
+        p8-platform \
+    && apk add --no-cache --virtual .build-dependencies \
+        build-base \
+        cmake \
+        eudev-dev \
+        swig \
+        p8-platform-dev \
+        linux-headers \
+    && git clone --depth 1 -b libcec-${LIBCEC_VERSION} https://github.com/Pulse-Eight/libcec /usr/src/libcec \
+    && cd /usr/src/libcec \
+    && mkdir -p /usr/src/libcec/build \
+    && cd /usr/src/libcec/build \
+    && cmake -DCMAKE_INSTALL_PREFIX:PATH=/usr/local \
+        -DPYTHON_LIBRARY="/usr/local/lib/libpython3.8.so" \
+        -DPYTHON_INCLUDE_DIR="/usr/local/include/python3.8" \
+        -DHAVE_LINUX_API=1 \
+        -DHAVE_AOCEC_API=1 \
+        .. \
+    && make -j$(nproc) \
+    && make install \
+    && echo "cec" > "/usr/local/lib/python3.8/site-packages/cec.pth" \
+    && apk del .build-dependencies \
+    && rm -rf /usr/src/libcec*
diff --git a/machine/odroid-xu b/machine/odroid-xu
new file mode 100644
index 00000000000..1947115f672
--- /dev/null
+++ b/machine/odroid-xu
@@ -0,0 +1,34 @@
+ARG BUILD_VERSION
+FROM homeassistant/armv7-homeassistant:$BUILD_VERSION
+
+RUN apk --no-cache add \
+    usbutils
+
+##
+# Build libcec for HDMI-CEC
+ARG LIBCEC_VERSION=6.0.2
+RUN apk add --no-cache \
+        eudev-libs \
+        p8-platform \
+    && apk add --no-cache --virtual .build-dependencies \
+        build-base \
+        cmake \
+        eudev-dev \
+        swig \
+        p8-platform-dev \
+        linux-headers \
+    && git clone --depth 1 -b libcec-${LIBCEC_VERSION} https://github.com/Pulse-Eight/libcec /usr/src/libcec \
+    && cd /usr/src/libcec \
+    && mkdir -p /usr/src/libcec/build \
+    && cd /usr/src/libcec/build \
+    && cmake -DCMAKE_INSTALL_PREFIX:PATH=/usr/local \
+        -DPYTHON_LIBRARY="/usr/local/lib/libpython3.8.so" \
+        -DPYTHON_INCLUDE_DIR="/usr/local/include/python3.8" \
+        -DHAVE_LINUX_API=1 \
+        -DHAVE_EXYNOS_API=1 \
+        .. \
+    && make -j$(nproc) \
+    && make install \
+    && echo "cec" > "/usr/local/lib/python3.8/site-packages/cec.pth" \
+    && apk del .build-dependencies \
+    && rm -rf /usr/src/libcec*
diff --git a/machine/qemuarm b/machine/qemuarm
new file mode 100644
index 00000000000..2735a7bae23
--- /dev/null
+++ b/machine/qemuarm
@@ -0,0 +1,33 @@
+ARG BUILD_VERSION
+FROM homeassistant/armhf-homeassistant:$BUILD_VERSION
+
+RUN apk --no-cache add \
+    usbutils
+
+##
+# Build libcec for HDMI-CEC
+ARG LIBCEC_VERSION=6.0.2
+RUN apk add --no-cache \
+        eudev-libs \
+        p8-platform \
+    && apk add --no-cache --virtual .build-dependencies \
+        build-base \
+        cmake \
+        eudev-dev \
+        swig \
+        p8-platform-dev \
+        linux-headers \
+    && git clone --depth 1 -b libcec-${LIBCEC_VERSION} https://github.com/Pulse-Eight/libcec /usr/src/libcec \
+    && cd /usr/src/libcec \
+    && mkdir -p /usr/src/libcec/build \
+    && cd /usr/src/libcec/build \
+    && cmake -DCMAKE_INSTALL_PREFIX:PATH=/usr/local \
+        -DPYTHON_LIBRARY="/usr/local/lib/libpython3.8.so" \
+        -DPYTHON_INCLUDE_DIR="/usr/local/include/python3.8" \
+        -DHAVE_LINUX_API=1 \
+        .. \
+    && make -j$(nproc) \
+    && make install \
+    && echo "cec" > "/usr/local/lib/python3.8/site-packages/cec.pth" \
+    && apk del .build-dependencies \
+    && rm -rf /usr/src/libcec*
diff --git a/machine/qemuarm-64 b/machine/qemuarm-64
new file mode 100644
index 00000000000..5783de82f58
--- /dev/null
+++ b/machine/qemuarm-64
@@ -0,0 +1,33 @@
+ARG BUILD_VERSION
+FROM homeassistant/aarch64-homeassistant:$BUILD_VERSION
+
+RUN apk --no-cache add \
+    usbutils
+
+##
+# Build libcec for HDMI-CEC
+ARG LIBCEC_VERSION=6.0.2
+RUN apk add --no-cache \
+        eudev-libs \
+        p8-platform \
+    && apk add --no-cache --virtual .build-dependencies \
+        build-base \
+        cmake \
+        eudev-dev \
+        swig \
+        p8-platform-dev \
+        linux-headers \
+    && git clone --depth 1 -b libcec-${LIBCEC_VERSION} https://github.com/Pulse-Eight/libcec /usr/src/libcec \
+    && cd /usr/src/libcec \
+    && mkdir -p /usr/src/libcec/build \
+    && cd /usr/src/libcec/build \
+    && cmake -DCMAKE_INSTALL_PREFIX:PATH=/usr/local \
+        -DPYTHON_LIBRARY="/usr/local/lib/libpython3.8.so" \
+        -DPYTHON_INCLUDE_DIR="/usr/local/include/python3.8" \
+        -DHAVE_LINUX_API=1 \
+        .. \
+    && make -j$(nproc) \
+    && make install \
+    && echo "cec" > "/usr/local/lib/python3.8/site-packages/cec.pth" \
+    && apk del .build-dependencies \
+    && rm -rf /usr/src/libcec*
diff --git a/machine/qemux86 b/machine/qemux86
new file mode 100644
index 00000000000..192d287dfde
--- /dev/null
+++ b/machine/qemux86
@@ -0,0 +1,33 @@
+ARG BUILD_VERSION
+FROM homeassistant/i386-homeassistant:$BUILD_VERSION
+
+RUN apk --no-cache add \
+    usbutils
+
+##
+# Build libcec for HDMI-CEC
+ARG LIBCEC_VERSION=6.0.2
+RUN apk add --no-cache \
+        eudev-libs \
+        p8-platform \
+    && apk add --no-cache --virtual .build-dependencies \
+        build-base \
+        cmake \
+        eudev-dev \
+        swig \
+        p8-platform-dev \
+        linux-headers \
+    && git clone --depth 1 -b libcec-${LIBCEC_VERSION} https://github.com/Pulse-Eight/libcec /usr/src/libcec \
+    && cd /usr/src/libcec \
+    && mkdir -p /usr/src/libcec/build \
+    && cd /usr/src/libcec/build \
+    && cmake -DCMAKE_INSTALL_PREFIX:PATH=/usr/local \
+        -DPYTHON_LIBRARY="/usr/local/lib/libpython3.8.so" \
+        -DPYTHON_INCLUDE_DIR="/usr/local/include/python3.8" \
+        -DHAVE_LINUX_API=1 \
+        .. \
+    && make -j$(nproc) \
+    && make install \
+    && echo "cec" > "/usr/local/lib/python3.8/site-packages/cec.pth" \
+    && apk del .build-dependencies \
+    && rm -rf /usr/src/libcec*
diff --git a/machine/qemux86-64 b/machine/qemux86-64
new file mode 100644
index 00000000000..5f4ca461ae8
--- /dev/null
+++ b/machine/qemux86-64
@@ -0,0 +1,33 @@
+ARG BUILD_VERSION
+FROM homeassistant/amd64-homeassistant:$BUILD_VERSION
+
+RUN apk --no-cache add \
+    usbutils
+
+##
+# Build libcec for HDMI-CEC
+ARG LIBCEC_VERSION=6.0.2
+RUN apk add --no-cache \
+        eudev-libs \
+        p8-platform \
+    && apk add --no-cache --virtual .build-dependencies \
+        build-base \
+        cmake \
+        eudev-dev \
+        swig \
+        p8-platform-dev \
+        linux-headers \
+    && git clone --depth 1 -b libcec-${LIBCEC_VERSION} https://github.com/Pulse-Eight/libcec /usr/src/libcec \
+    && cd /usr/src/libcec \
+    && mkdir -p /usr/src/libcec/build \
+    && cd /usr/src/libcec/build \
+    && cmake -DCMAKE_INSTALL_PREFIX:PATH=/usr/local \
+        -DPYTHON_LIBRARY="/usr/local/lib/libpython3.8.so" \
+        -DPYTHON_INCLUDE_DIR="/usr/local/include/python3.8" \
+        -DHAVE_LINUX_API=1 \
+        .. \
+    && make -j$(nproc) \
+    && make install \
+    && echo "cec" > "/usr/local/lib/python3.8/site-packages/cec.pth" \
+    && apk del .build-dependencies \
+    && rm -rf /usr/src/libcec*
diff --git a/machine/raspberrypi b/machine/raspberrypi
new file mode 100644
index 00000000000..d7add9bf63f
--- /dev/null
+++ b/machine/raspberrypi
@@ -0,0 +1,61 @@
+ARG BUILD_VERSION
+FROM homeassistant/armhf-homeassistant:$BUILD_VERSION
+
+RUN apk --no-cache add \
+        raspberrypi \
+        raspberrypi-libs \
+        usbutils \
+    && sed -i "s|# RPi.GPIO|RPi.GPIO|g" /usr/src/homeassistant/requirements_all.txt \
+    && pip3 install --no-cache-dir --no-index --only-binary=:all: --find-links "${WHEELS_LINKS}" \
+        RPi.GPIO -c /usr/src/homeassistant/requirements_all.txt
+
+##
+# Set symlinks for raspberry pi camera binaries.
+RUN ln -sv /opt/vc/bin/raspistill /usr/local/bin/raspistill \
+    && ln -sv /opt/vc/bin/raspivid /usr/local/bin/raspivid \
+    && ln -sv /opt/vc/bin/raspividyuv /usr/local/bin/raspividyuv \
+    && ln -sv /opt/vc/bin/raspiyuv /usr/local/bin/raspiyuv
+
+##
+# Build libcec with RPi support for HDMI-CEC
+ARG LIBCEC_VERSION=6.0.2
+RUN apk add --no-cache \
+        eudev-libs \
+        p8-platform \
+    && apk add --no-cache --virtual .build-dependencies \
+        build-base \
+        cmake \
+        eudev-dev \
+        swig \
+        raspberrypi-dev \
+        p8-platform-dev \
+    && git clone --depth 1 -b libcec-${LIBCEC_VERSION} https://github.com/Pulse-Eight/libcec /usr/src/libcec \
+    && mkdir -p /usr/src/libcec/build \
+    && cd /usr/src/libcec/build \
+    && cmake -DCMAKE_INSTALL_PREFIX:PATH=/usr/local \
+        -DRPI_INCLUDE_DIR=/opt/vc/include \
+        -DRPI_LIB_DIR=/opt/vc/lib \
+        -DPYTHON_LIBRARY="/usr/local/lib/libpython3.8.so" \
+        -DPYTHON_INCLUDE_DIR="/usr/local/include/python3.8" \
+        .. \
+    && make -j$(nproc) \
+    && make install \
+    && echo "cec" > "/usr/local/lib/python3.8/site-packages/cec.pth" \
+    && apk del .build-dependencies \
+    && rm -rf /usr/src/libcec
+ENV LD_LIBRARY_PATH=/opt/vc/lib:${LD_LIBRARY_PATH}
+
+##
+# Install DHT
+RUN apk add --no-cache --virtual .build-dependencies \
+        gcc libc-dev raspberrypi-dev \
+    && export DHT_VERSION="$(cat /usr/src/homeassistant/requirements_all.txt | sed -n 's|.*Adafruit-DHT==\([0-9\.]*\).*|\1|p')" \
+    && git clone --depth 1 -b ${DHT_VERSION} https://github.com/adafruit/Adafruit_Python_DHT /usr/src/dht \
+    && cd /usr/src/dht \
+    && sed -i 's/^pi_version\ =\ None/pi_version\ =\ 1/' setup.py \
+    && sed -i 's/^platform\ =\ platform_detect.UNKNOWN/platform\ =\ platform_detect.RASPBERRY_PI/' setup.py \
+    && sed -i 's/platform\ =\ platform_detect.platform_detect()/pass/' setup.py \
+    && export MAKEFLAGS="-j$(nproc)" \
+    && pip3 install . \
+    && apk del .build-dependencies \
+    && rm -rf /usr/src/dht
diff --git a/machine/raspberrypi2 b/machine/raspberrypi2
new file mode 100644
index 00000000000..2643af911a4
--- /dev/null
+++ b/machine/raspberrypi2
@@ -0,0 +1,61 @@
+ARG BUILD_VERSION
+FROM homeassistant/armv7-homeassistant:$BUILD_VERSION
+
+RUN apk --no-cache add \
+        raspberrypi \
+        raspberrypi-libs \
+        usbutils \
+    && sed -i "s|# RPi.GPIO|RPi.GPIO|g" /usr/src/homeassistant/requirements_all.txt \
+    && pip3 install --no-cache-dir --no-index --only-binary=:all: --find-links "${WHEELS_LINKS}" \
+        RPi.GPIO -c /usr/src/homeassistant/requirements_all.txt
+
+##
+# Set symlinks for raspberry pi binaries.
+RUN ln -sv /opt/vc/bin/raspistill /usr/local/bin/raspistill \
+    && ln -sv /opt/vc/bin/raspivid /usr/local/bin/raspivid \
+    && ln -sv /opt/vc/bin/raspividyuv /usr/local/bin/raspividyuv \
+    && ln -sv /opt/vc/bin/raspiyuv /usr/local/bin/raspiyuv
+
+##
+# Build libcec with RPi support for HDMI-CEC
+ARG LIBCEC_VERSION=6.0.2
+RUN apk add --no-cache \
+        eudev-libs \
+        p8-platform \
+    && apk add --no-cache --virtual .build-dependencies \
+        build-base \
+        cmake \
+        eudev-dev \
+        swig \
+        raspberrypi-dev \
+        p8-platform-dev \
+    && git clone --depth 1 -b libcec-${LIBCEC_VERSION} https://github.com/Pulse-Eight/libcec /usr/src/libcec \
+    && mkdir -p /usr/src/libcec/build \
+    && cd /usr/src/libcec/build \
+    && cmake -DCMAKE_INSTALL_PREFIX:PATH=/usr/local \
+        -DRPI_INCLUDE_DIR=/opt/vc/include \
+        -DRPI_LIB_DIR=/opt/vc/lib \
+        -DPYTHON_LIBRARY="/usr/local/lib/libpython3.8.so" \
+        -DPYTHON_INCLUDE_DIR="/usr/local/include/python3.8" \
+        .. \
+    && make -j$(nproc) \
+    && make install \
+    && echo "cec" > "/usr/local/lib/python3.8/site-packages/cec.pth" \
+    && apk del .build-dependencies \
+    && rm -rf /usr/src/libcec
+ENV LD_LIBRARY_PATH=/opt/vc/lib:${LD_LIBRARY_PATH}
+
+##
+# Install DHT
+RUN apk add --no-cache --virtual .build-dependencies \
+        gcc libc-dev raspberrypi-dev \
+    && export DHT_VERSION="$(cat /usr/src/homeassistant/requirements_all.txt | sed -n 's|.*Adafruit-DHT==\([0-9\.]*\).*|\1|p')" \
+    && git clone --depth 1 -b ${DHT_VERSION} https://github.com/adafruit/Adafruit_Python_DHT /usr/src/dht \
+    && cd /usr/src/dht \
+    && sed -i 's/^pi_version\ =\ None/pi_version\ =\ 2/' setup.py \
+    && sed -i 's/^platform\ =\ platform_detect.UNKNOWN/platform\ =\ platform_detect.RASPBERRY_PI/' setup.py \
+    && sed -i 's/platform\ =\ platform_detect.platform_detect()/pass/' setup.py \
+    && export MAKEFLAGS="-j$(nproc)" \
+    && pip3 install . \
+    && apk del .build-dependencies \
+    && rm -rf /usr/src/dht
diff --git a/machine/raspberrypi3 b/machine/raspberrypi3
new file mode 100644
index 00000000000..5aed2308ef6
--- /dev/null
+++ b/machine/raspberrypi3
@@ -0,0 +1,61 @@
+ARG BUILD_VERSION
+FROM homeassistant/armv7-homeassistant:$BUILD_VERSION
+
+RUN apk --no-cache add \
+        raspberrypi \
+        raspberrypi-libs \
+        usbutils \
+    && sed -i "s|# RPi.GPIO|RPi.GPIO|g" /usr/src/homeassistant/requirements_all.txt \
+    && pip3 install --no-cache-dir --no-index --only-binary=:all: --find-links "${WHEELS_LINKS}" \
+        RPi.GPIO bluepy pybluez -c /usr/src/homeassistant/requirements_all.txt
+
+##
+# Set symlinks for raspberry pi binaries.
+RUN ln -sv /opt/vc/bin/raspistill /usr/local/bin/raspistill \
+    && ln -sv /opt/vc/bin/raspivid /usr/local/bin/raspivid \
+    && ln -sv /opt/vc/bin/raspividyuv /usr/local/bin/raspividyuv \
+    && ln -sv /opt/vc/bin/raspiyuv /usr/local/bin/raspiyuv
+
+##
+# Build libcec with RPi support for HDMI-CEC
+ARG LIBCEC_VERSION=6.0.2
+RUN apk add --no-cache \
+        eudev-libs \
+        p8-platform \
+    && apk add --no-cache --virtual .build-dependencies \
+        build-base \
+        cmake \
+        eudev-dev \
+        swig \
+        raspberrypi-dev \
+        p8-platform-dev \
+    && git clone --depth 1 -b libcec-${LIBCEC_VERSION} https://github.com/Pulse-Eight/libcec /usr/src/libcec \
+    && mkdir -p /usr/src/libcec/build \
+    && cd /usr/src/libcec/build \
+    && cmake -DCMAKE_INSTALL_PREFIX:PATH=/usr/local \
+        -DRPI_INCLUDE_DIR=/opt/vc/include \
+        -DRPI_LIB_DIR=/opt/vc/lib \
+        -DPYTHON_LIBRARY="/usr/local/lib/libpython3.8.so" \
+        -DPYTHON_INCLUDE_DIR="/usr/local/include/python3.8" \
+        .. \
+    && make -j$(nproc) \
+    && make install \
+    && echo "cec" > "/usr/local/lib/python3.8/site-packages/cec.pth" \
+    && apk del .build-dependencies \
+    && rm -rf /usr/src/libcec
+ENV LD_LIBRARY_PATH=/opt/vc/lib:${LD_LIBRARY_PATH}
+
+##
+# Install DHT
+RUN apk add --no-cache --virtual .build-dependencies \
+        gcc libc-dev raspberrypi-dev \
+    && export DHT_VERSION="$(cat /usr/src/homeassistant/requirements_all.txt | sed -n 's|.*Adafruit-DHT==\([0-9\.]*\).*|\1|p')" \
+    && git clone --depth 1 -b ${DHT_VERSION} https://github.com/adafruit/Adafruit_Python_DHT /usr/src/dht \
+    && cd /usr/src/dht \
+    && sed -i 's/^pi_version\ =\ None/pi_version\ =\ 3/' setup.py \
+    && sed -i 's/^platform\ =\ platform_detect.UNKNOWN/platform\ =\ platform_detect.RASPBERRY_PI/' setup.py \
+    && sed -i 's/platform\ =\ platform_detect.platform_detect()/pass/' setup.py \
+    && export MAKEFLAGS="-j$(nproc)" \
+    && pip3 install . \
+    && apk del .build-dependencies \
+    && rm -rf /usr/src/dht
diff --git a/machine/raspberrypi3-64 b/machine/raspberrypi3-64
new file mode 100644
index 00000000000..1b31726c879
--- /dev/null
+++ b/machine/raspberrypi3-64
@@ -0,0 +1,61 @@
+ARG BUILD_VERSION
+FROM homeassistant/aarch64-homeassistant:$BUILD_VERSION
+
+RUN apk --no-cache add \
+        raspberrypi \
+        raspberrypi-libs \
+        usbutils \
+    && sed -i "s|# RPi.GPIO|RPi.GPIO|g" /usr/src/homeassistant/requirements_all.txt \
+    && pip3 install --no-cache-dir --no-index --only-binary=:all: --find-links "${WHEELS_LINKS}" \
+        RPi.GPIO bluepy pybluez -c /usr/src/homeassistant/requirements_all.txt
+
+##
+# Set symlinks for raspberry pi binaries.
+RUN ln -sv /opt/vc/bin/raspistill /usr/local/bin/raspistill \
+    && ln -sv /opt/vc/bin/raspivid /usr/local/bin/raspivid \
+    && ln -sv /opt/vc/bin/raspividyuv /usr/local/bin/raspividyuv \
+    && ln -sv /opt/vc/bin/raspiyuv /usr/local/bin/raspiyuv
+
+##
+# Build libcec with RPi support for HDMI-CEC
+ARG LIBCEC_VERSION=6.0.2
+RUN apk add --no-cache \
+        eudev-libs \
+        p8-platform \
+    && apk add --no-cache --virtual .build-dependencies \
+        build-base \
+        cmake \
+        eudev-dev \
+        swig \
+        raspberrypi-dev \
+        p8-platform-dev \
+    && git clone --depth 1 -b libcec-${LIBCEC_VERSION} https://github.com/Pulse-Eight/libcec /usr/src/libcec \
+    && mkdir -p /usr/src/libcec/build \
+    && cd /usr/src/libcec/build \
+    && cmake -DCMAKE_INSTALL_PREFIX:PATH=/usr/local \
+        -DRPI_INCLUDE_DIR=/opt/vc/include \
+        -DRPI_LIB_DIR=/opt/vc/lib \
+        -DPYTHON_LIBRARY="/usr/local/lib/libpython3.8.so" \
+        -DPYTHON_INCLUDE_DIR="/usr/local/include/python3.8" \
+        .. \
+    && make -j$(nproc) \
+    && make install \
+    && echo "cec" > "/usr/local/lib/python3.8/site-packages/cec.pth" \
+    && apk del .build-dependencies \
+    && rm -rf /usr/src/libcec
+ENV LD_LIBRARY_PATH=/opt/vc/lib:${LD_LIBRARY_PATH}
+
+##
+# Install DHT
+RUN apk add --no-cache --virtual .build-dependencies \
+        gcc libc-dev raspberrypi-dev \
+    && export DHT_VERSION="$(cat /usr/src/homeassistant/requirements_all.txt | sed -n 's|.*Adafruit-DHT==\([0-9\.]*\).*|\1|p')" \
+    && git clone --depth 1 -b ${DHT_VERSION} https://github.com/adafruit/Adafruit_Python_DHT /usr/src/dht \
+    && cd /usr/src/dht \
+    && sed -i 's/^pi_version\ =\ None/pi_version\ =\ 3/' setup.py \
+    && sed -i 's/^platform\ =\ platform_detect.UNKNOWN/platform\ =\ platform_detect.RASPBERRY_PI/' setup.py \
+    && sed -i 's/platform\ =\ platform_detect.platform_detect()/pass/' setup.py \
+    && export MAKEFLAGS="-j$(nproc)" \
+    && pip3 install . \
+    && apk del .build-dependencies \
+    && rm -rf /usr/src/dht
diff --git a/machine/raspberrypi4 b/machine/raspberrypi4
new file mode 100644
index 00000000000..5aed2308ef6
--- /dev/null
+++ b/machine/raspberrypi4
@@ -0,0 +1,61 @@
+ARG BUILD_VERSION
+FROM homeassistant/armv7-homeassistant:$BUILD_VERSION
+
+RUN apk --no-cache add \
+        raspberrypi \
+        raspberrypi-libs \
+        usbutils \
+    && sed -i "s|# RPi.GPIO|RPi.GPIO|g" /usr/src/homeassistant/requirements_all.txt \
+    && pip3 install --no-cache-dir --no-index --only-binary=:all: --find-links "${WHEELS_LINKS}" \
+        RPi.GPIO bluepy pybluez -c /usr/src/homeassistant/requirements_all.txt
+
+##
+# Set symlinks for raspberry pi binaries.
+RUN ln -sv /opt/vc/bin/raspistill /usr/local/bin/raspistill \
+    && ln -sv /opt/vc/bin/raspivid /usr/local/bin/raspivid \
+    && ln -sv /opt/vc/bin/raspividyuv /usr/local/bin/raspividyuv \
+    && ln -sv /opt/vc/bin/raspiyuv /usr/local/bin/raspiyuv
+
+##
+# Build libcec with RPi support for HDMI-CEC
+ARG LIBCEC_VERSION=6.0.2
+RUN apk add --no-cache \
+        eudev-libs \
+        p8-platform \
+    && apk add --no-cache --virtual .build-dependencies \
+        build-base \
+        cmake \
+        eudev-dev \
+        swig \
+        raspberrypi-dev \
+        p8-platform-dev \
+    && git clone --depth 1 -b libcec-${LIBCEC_VERSION} https://github.com/Pulse-Eight/libcec /usr/src/libcec \
+    && mkdir -p /usr/src/libcec/build \
+    && cd /usr/src/libcec/build \
+    && cmake -DCMAKE_INSTALL_PREFIX:PATH=/usr/local \
+        -DRPI_INCLUDE_DIR=/opt/vc/include \
+        -DRPI_LIB_DIR=/opt/vc/lib \
+        -DPYTHON_LIBRARY="/usr/local/lib/libpython3.8.so" \
+        -DPYTHON_INCLUDE_DIR="/usr/local/include/python3.8" \
+        .. \
+    && make -j$(nproc) \
+    && make install \
+    && echo "cec" > "/usr/local/lib/python3.8/site-packages/cec.pth" \
+    && apk del .build-dependencies \
+    && rm -rf /usr/src/libcec
+ENV LD_LIBRARY_PATH=/opt/vc/lib:${LD_LIBRARY_PATH}
+
+##
+# Install DHT
+RUN apk add --no-cache --virtual .build-dependencies \
+        gcc libc-dev raspberrypi-dev \
+    && export DHT_VERSION="$(cat /usr/src/homeassistant/requirements_all.txt | sed -n 's|.*Adafruit-DHT==\([0-9\.]*\).*|\1|p')" \
+    && git clone --depth 1 -b ${DHT_VERSION} https://github.com/adafruit/Adafruit_Python_DHT /usr/src/dht \
+    && cd /usr/src/dht \
+    && sed -i 's/^pi_version\ =\ None/pi_version\ =\ 3/' setup.py \
+    && sed -i 's/^platform\ =\ platform_detect.UNKNOWN/platform\ =\ platform_detect.RASPBERRY_PI/' setup.py \
+    && sed -i 's/platform\ =\ platform_detect.platform_detect()/pass/' setup.py \
+    && export MAKEFLAGS="-j$(nproc)" \
+    && pip3 install . \
+    && apk del .build-dependencies \
+    && rm -rf /usr/src/dht
diff --git a/machine/raspberrypi4-64 b/machine/raspberrypi4-64
new file mode 100644
index 00000000000..1b31726c879
--- /dev/null
+++ b/machine/raspberrypi4-64
@@ -0,0 +1,61 @@
+ARG BUILD_VERSION
+FROM homeassistant/aarch64-homeassistant:$BUILD_VERSION
+
+RUN apk --no-cache add \
+        raspberrypi \
+        raspberrypi-libs \
+        usbutils \
+    && sed -i "s|# RPi.GPIO|RPi.GPIO|g" /usr/src/homeassistant/requirements_all.txt \
+    && pip3 install --no-cache-dir --no-index --only-binary=:all: --find-links "${WHEELS_LINKS}" \
+        RPi.GPIO bluepy pybluez -c /usr/src/homeassistant/requirements_all.txt
+
+##
+# Set symlinks for raspberry pi binaries.
+RUN ln -sv /opt/vc/bin/raspistill /usr/local/bin/raspistill \
+    && ln -sv /opt/vc/bin/raspivid /usr/local/bin/raspivid \
+    && ln -sv /opt/vc/bin/raspividyuv /usr/local/bin/raspividyuv \
+    && ln -sv /opt/vc/bin/raspiyuv /usr/local/bin/raspiyuv
+
+##
+# Build libcec with RPi support for HDMI-CEC
+ARG LIBCEC_VERSION=6.0.2
+RUN apk add --no-cache \
+        eudev-libs \
+        p8-platform \
+    && apk add --no-cache --virtual .build-dependencies \
+        build-base \
+        cmake \
+        eudev-dev \
+        swig \
+        raspberrypi-dev \
+        p8-platform-dev \
+    && git clone --depth 1 -b libcec-${LIBCEC_VERSION} https://github.com/Pulse-Eight/libcec /usr/src/libcec \
+    && mkdir -p /usr/src/libcec/build \
+    && cd /usr/src/libcec/build \
+    && cmake -DCMAKE_INSTALL_PREFIX:PATH=/usr/local \
+        -DRPI_INCLUDE_DIR=/opt/vc/include \
+        -DRPI_LIB_DIR=/opt/vc/lib \
+        -DPYTHON_LIBRARY="/usr/local/lib/libpython3.8.so" \
+        -DPYTHON_INCLUDE_DIR="/usr/local/include/python3.8" \
+        .. \
+    && make -j$(nproc) \
+    && make install \
+    && echo "cec" > "/usr/local/lib/python3.8/site-packages/cec.pth" \
+    && apk del .build-dependencies \
+    && rm -rf /usr/src/libcec
+ENV LD_LIBRARY_PATH=/opt/vc/lib:${LD_LIBRARY_PATH}
+
+##
+# Install DHT
+RUN apk add --no-cache --virtual .build-dependencies \
+        gcc libc-dev raspberrypi-dev \
+    && export DHT_VERSION="$(cat /usr/src/homeassistant/requirements_all.txt | sed -n 's|.*Adafruit-DHT==\([0-9\.]*\).*|\1|p')" \
+    && git clone --depth 1 -b ${DHT_VERSION} https://github.com/adafruit/Adafruit_Python_DHT /usr/src/dht \
+    && cd /usr/src/dht \
+    && sed -i 's/^pi_version\ =\ None/pi_version\ =\ 3/' setup.py \
+    && sed -i 's/^platform\ =\ platform_detect.UNKNOWN/platform\ =\ platform_detect.RASPBERRY_PI/' setup.py \
+    && sed -i 's/platform\ =\ platform_detect.platform_detect()/pass/' setup.py \
+    && export MAKEFLAGS="-j$(nproc)" \
+    && pip3 install . \
+    && apk del .build-dependencies \
+    && rm -rf /usr/src/dht
diff --git a/machine/tinker b/machine/tinker
new file mode 100644
index 00000000000..46b627c2257
--- /dev/null
+++ b/machine/tinker
@@ -0,0 +1,48 @@
+ARG BUILD_VERSION
+FROM homeassistant/armv7-homeassistant:$BUILD_VERSION
+
+RUN apk --no-cache add usbutils \
+    && pip3 install --no-cache-dir --no-index --only-binary=:all: --find-links "${WHEELS_LINKS}" \
+        -c /usr/src/homeassistant/homeassistant/package_constraints.txt \
+        bluepy \
+        pybluez \
+        pygatt[GATTTOOL]
+
+# Install GPIO support
+RUN apk add --no-cache --virtual .build-dependencies \
+        gcc libc-dev musl-dev \
+    && git clone --depth 1 https://github.com/TinkerBoard/gpio_lib_python /usr/src/gpio \
+    && cd /usr/src/gpio \
+    && sed -i "s/caddr_t/void*/g" source/wiringTB.c \
+    && export MAKEFLAGS="-j$(nproc)" \
+    && python3 setup.py install \
+    && apk del .build-dependencies \
+    && rm -rf /usr/src/gpio
+
+##
+# Build libcec for HDMI-CEC
+ARG LIBCEC_VERSION=6.0.2
+RUN apk add --no-cache \
+        eudev-libs \
+        p8-platform \
+    && apk add --no-cache --virtual .build-dependencies \
+        build-base \
+        cmake \
+        eudev-dev \
+        swig \
+        p8-platform-dev \
+        linux-headers \
+    && git clone --depth 1 -b libcec-${LIBCEC_VERSION} https://github.com/Pulse-Eight/libcec /usr/src/libcec \
+    && cd /usr/src/libcec \
+    && mkdir -p /usr/src/libcec/build \
+    && cd /usr/src/libcec/build \
+    && cmake -DCMAKE_INSTALL_PREFIX:PATH=/usr/local \
+        -DPYTHON_LIBRARY="/usr/local/lib/libpython3.8.so" \
+        -DPYTHON_INCLUDE_DIR="/usr/local/include/python3.8" \
+        -DHAVE_LINUX_API=1 \
+        .. \
+    && make -j$(nproc) \
+    && make install \
+    && echo "cec" > "/usr/local/lib/python3.8/site-packages/cec.pth" \
+    && apk del .build-dependencies \
+    && rm -rf /usr/src/libcec*

From 06b99a1ff93bf826d28b6edb08f71f5984a14d99 Mon Sep 17 00:00:00 2001
From: djtimca <60706061+djtimca@users.noreply.github.com>
Date: Tue, 13 Oct 2020 15:32:32 -0400
Subject: [PATCH 72/82] Fix issues with metric conversion and single pump type
 for filter pumps in Omnilogic integration (#41777)

---
 homeassistant/components/omnilogic/sensor.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/homeassistant/components/omnilogic/sensor.py b/homeassistant/components/omnilogic/sensor.py
index e3324cfabc3..deaee33ed82 100644
--- a/homeassistant/components/omnilogic/sensor.py
+++ b/homeassistant/components/omnilogic/sensor.py
@@ -175,7 +175,7 @@ class OmniLogicSaltLevelSensor(OmnilogicSensor):
         unit_of_measurement = self._unit
 
         if self._unit_type == "Metric":
-            salt_return = round(salt_return / 1000, 2)
+            salt_return = round(int(salt_return) / 1000, 2)
             unit_of_measurement = f"{MASS_GRAMS}/{VOLUME_LITERS}"
 
         self._unit = unit_of_measurement
@@ -279,7 +279,7 @@ SENSOR_TYPES = {
             "icon": "mdi:speedometer",
             "unit": PERCENTAGE,
             "guard_condition": [
-                {"Type": "FMT_SINGLE_SPEED"},
+                {"Filter-Type": "FMT_SINGLE_SPEED"},
             ],
         },
     ],

From efffc82414ba8698847da6ee8df8cfe8f831945a Mon Sep 17 00:00:00 2001
From: Aaron Bach <bachya1208@gmail.com>
Date: Thu, 15 Oct 2020 02:15:32 -0600
Subject: [PATCH 73/82] Fix SimpliSafe re-auth flow (#41805)

Co-authored-by: Paulus Schoutsen <paulus@home-assistant.io>
---
 .../components/simplisafe/__init__.py         | 34 ++++++++++++-------
 1 file changed, 21 insertions(+), 13 deletions(-)

diff --git a/homeassistant/components/simplisafe/__init__.py b/homeassistant/components/simplisafe/__init__.py
index 0a42d42be3a..dc2474cab88 100644
--- a/homeassistant/components/simplisafe/__init__.py
+++ b/homeassistant/components/simplisafe/__init__.py
@@ -16,7 +16,7 @@ from simplipy.websocket import (
 )
 import voluptuous as vol
 
-from homeassistant.config_entries import SOURCE_IMPORT
+from homeassistant.config_entries import SOURCE_IMPORT, SOURCE_REAUTH
 from homeassistant.const import (
     ATTR_CODE,
     CONF_CODE,
@@ -365,8 +365,7 @@ async def async_unload_entry(hass, entry):
 
 async def async_update_options(hass, config_entry):
     """Handle an options update."""
-    simplisafe = hass.data[DOMAIN][DATA_CLIENT][config_entry.entry_id]
-    simplisafe.options = config_entry.options
+    await hass.config_entries.async_reload(config_entry.entry_id)
 
 
 class SimpliSafeWebsocket:
@@ -530,17 +529,26 @@ class SimpliSafe:
         for result in results:
             if isinstance(result, InvalidCredentialsError):
                 if self._emergency_refresh_token_used:
-                    LOGGER.error(
-                        "Token disconnected or invalid. Please re-auth the "
-                        "SimpliSafe integration in HASS"
-                    )
-                    self._hass.async_create_task(
-                        self._hass.config_entries.flow.async_init(
-                            DOMAIN,
-                            context={"source": "reauth"},
-                            data=self._config_entry.data,
+                    matching_flows = [
+                        flow
+                        for flow in self._hass.config_entries.flow.async_progress()
+                        if flow["context"].get("source") == SOURCE_REAUTH
+                        and flow["context"].get("unique_id")
+                        == self._config_entry.unique_id
+                    ]
+
+                    if not matching_flows:
+                        self._hass.async_create_task(
+                            self._hass.config_entries.flow.async_init(
+                                DOMAIN,
+                                context={
+                                    "source": SOURCE_REAUTH,
+                                    "unique_id": self._config_entry.unique_id,
+                                },
+                                data=self._config_entry.data,
+                            )
                         )
-                    )
+
                     return
 
                 LOGGER.warning("SimpliSafe cloud error; trying stored refresh token")

From 8d5e15df3d95af2f5b0f00f957bed2b6d77d92f4 Mon Sep 17 00:00:00 2001
From: Simone Chemelli <simone.chemelli@gmail.com>
Date: Wed, 14 Oct 2020 21:09:03 +0200
Subject: [PATCH 74/82] Shelly: fix for RGB devices (#41841)

---
 homeassistant/components/shelly/entity.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/homeassistant/components/shelly/entity.py b/homeassistant/components/shelly/entity.py
index 237deec4da1..7ffd1aee052 100644
--- a/homeassistant/components/shelly/entity.py
+++ b/homeassistant/components/shelly/entity.py
@@ -28,7 +28,7 @@ def shelly_naming(self, block, entity_type: str):
         return f"{entity_name} {self.description.name}"
 
     channels = 0
-    mode = "relays"
+    mode = block.type + "s"
     if "num_outputs" in self.wrapper.device.shelly:
         channels = self.wrapper.device.shelly["num_outputs"]
         if (
@@ -38,7 +38,6 @@ def shelly_naming(self, block, entity_type: str):
             channels = 1
         if block.type == "emeter" and "num_emeters" in self.wrapper.device.shelly:
             channels = self.wrapper.device.shelly["num_emeters"]
-            mode = "emeters"
     if channels > 1 and block.type != "device":
         # Shelly EM (SHEM) with firmware v1.8.1 doesn't have "name" key; will be fixed in next firmware release
         if "name" in self.wrapper.device.settings[mode][int(block.channel)]:

From 99010bab18de0c15fff0cb2fb7e3580d176108d0 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Thu, 15 Oct 2020 02:26:51 -0500
Subject: [PATCH 75/82] Permit event trackers to accept an empty list of
 entities or domains (#41857)

---
 homeassistant/helpers/event.py | 17 +++++++++++
 tests/helpers/test_event.py    | 52 ++++++++++++++++++++++++++++++++++
 2 files changed, 69 insertions(+)

diff --git a/homeassistant/helpers/event.py b/homeassistant/helpers/event.py
index b6d59bb500c..33d2082c99e 100644
--- a/homeassistant/helpers/event.py
+++ b/homeassistant/helpers/event.py
@@ -233,6 +233,9 @@ def async_track_state_change_event(
     care about the state change events so we can
     do a fast dict lookup to route events.
     """
+    entity_ids = _async_string_to_lower_list(entity_ids)
+    if not entity_ids:
+        return _remove_empty_listener
 
     entity_callbacks = hass.data.setdefault(TRACK_STATE_CHANGE_CALLBACKS, {})
 
@@ -277,6 +280,11 @@ def async_track_state_change_event(
     return remove_listener
 
 
+@callback
+def _remove_empty_listener() -> None:
+    """Remove a listener that does nothing."""
+
+
 @callback
 def _async_remove_indexed_listeners(
     hass: HomeAssistant,
@@ -309,6 +317,9 @@ def async_track_entity_registry_updated_event(
 
     Similar to async_track_state_change_event.
     """
+    entity_ids = _async_string_to_lower_list(entity_ids)
+    if not entity_ids:
+        return _remove_empty_listener
 
     entity_callbacks = hass.data.setdefault(TRACK_ENTITY_REGISTRY_UPDATED_CALLBACKS, {})
 
@@ -381,6 +392,9 @@ def async_track_state_added_domain(
     action: Callable[[Event], Any],
 ) -> Callable[[], None]:
     """Track state change events when an entity is added to domains."""
+    domains = _async_string_to_lower_list(domains)
+    if not domains:
+        return _remove_empty_listener
 
     domain_callbacks = hass.data.setdefault(TRACK_STATE_ADDED_DOMAIN_CALLBACKS, {})
 
@@ -424,6 +438,9 @@ def async_track_state_removed_domain(
     action: Callable[[Event], Any],
 ) -> Callable[[], None]:
     """Track state change events when an entity is removed from domains."""
+    domains = _async_string_to_lower_list(domains)
+    if not domains:
+        return _remove_empty_listener
 
     domain_callbacks = hass.data.setdefault(TRACK_STATE_REMOVED_DOMAIN_CALLBACKS, {})
 
diff --git a/tests/helpers/test_event.py b/tests/helpers/test_event.py
index bb0d17d7b0e..14b208b68d4 100644
--- a/tests/helpers/test_event.py
+++ b/tests/helpers/test_event.py
@@ -486,6 +486,19 @@ async def test_async_track_state_change_event(hass):
     unsub_throws()
 
 
+async def test_async_track_state_change_event_with_empty_list(hass):
+    """Test async_track_state_change_event passing an empty list of entities."""
+    unsub_single = async_track_state_change_event(
+        hass, [], ha.callback(lambda event: None)
+    )
+    unsub_single2 = async_track_state_change_event(
+        hass, [], ha.callback(lambda event: None)
+    )
+
+    unsub_single2()
+    unsub_single()
+
+
 async def test_async_track_state_added_domain(hass):
     """Test async_track_state_added_domain."""
     single_entity_id_tracker = []
@@ -568,6 +581,32 @@ async def test_async_track_state_added_domain(hass):
     unsub_throws()
 
 
+async def test_async_track_state_added_domain_with_empty_list(hass):
+    """Test async_track_state_added_domain passing an empty list of domains."""
+    unsub_single = async_track_state_added_domain(
+        hass, [], ha.callback(lambda event: None)
+    )
+    unsub_single2 = async_track_state_added_domain(
+        hass, [], ha.callback(lambda event: None)
+    )
+
+    unsub_single2()
+    unsub_single()
+
+
+async def test_async_track_state_removed_domain_with_empty_list(hass):
+    """Test async_track_state_removed_domain passing an empty list of domains."""
+    unsub_single = async_track_state_removed_domain(
+        hass, [], ha.callback(lambda event: None)
+    )
+    unsub_single2 = async_track_state_removed_domain(
+        hass, [], ha.callback(lambda event: None)
+    )
+
+    unsub_single2()
+    unsub_single()
+
+
 async def test_async_track_state_removed_domain(hass):
     """Test async_track_state_removed_domain."""
     single_entity_id_tracker = []
@@ -2876,3 +2915,16 @@ async def test_async_track_entity_registry_updated_event_with_a_callback_that_th
     unsub2()
 
     assert event_data[0] == {"action": "create", "entity_id": "switch.puppy_feeder"}
+
+
+async def test_async_track_entity_registry_updated_event_with_empty_list(hass):
+    """Test async_track_entity_registry_updated_event passing an empty list of entities."""
+    unsub_single = hass.helpers.event.async_track_entity_registry_updated_event(
+        [], ha.callback(lambda event: None)
+    )
+    unsub_single2 = hass.helpers.event.async_track_entity_registry_updated_event(
+        [], ha.callback(lambda event: None)
+    )
+
+    unsub_single2()
+    unsub_single()

From e80ffe16f736630c47a9dac1592860407ff28595 Mon Sep 17 00:00:00 2001
From: cgtobi <cgtobi@users.noreply.github.com>
Date: Thu, 15 Oct 2020 09:25:59 +0200
Subject: [PATCH 76/82] Reduce polling for Netatmo weather station sensors
 (#41858)

---
 homeassistant/components/netatmo/data_handler.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/homeassistant/components/netatmo/data_handler.py b/homeassistant/components/netatmo/data_handler.py
index c9be4237229..ae0995639c7 100644
--- a/homeassistant/components/netatmo/data_handler.py
+++ b/homeassistant/components/netatmo/data_handler.py
@@ -41,7 +41,7 @@ DEFAULT_INTERVALS = {
     HOMEDATA_DATA_CLASS_NAME: 900,
     HOMESTATUS_DATA_CLASS_NAME: 300,
     CAMERA_DATA_CLASS_NAME: 900,
-    WEATHERSTATION_DATA_CLASS_NAME: 300,
+    WEATHERSTATION_DATA_CLASS_NAME: 600,
     HOMECOACH_DATA_CLASS_NAME: 300,
     PUBLICDATA_DATA_CLASS_NAME: 600,
 }

From 8036b709e0847fe5e2d546f1e020145cc636d8a5 Mon Sep 17 00:00:00 2001
From: Paulus Schoutsen <balloob@gmail.com>
Date: Thu, 15 Oct 2020 08:42:52 +0000
Subject: [PATCH 77/82] Bumped version to 0.116.3

---
 homeassistant/const.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/homeassistant/const.py b/homeassistant/const.py
index 0acd31bc30a..a3ed164ecba 100644
--- a/homeassistant/const.py
+++ b/homeassistant/const.py
@@ -1,7 +1,7 @@
 """Constants used by Home Assistant components."""
 MAJOR_VERSION = 0
 MINOR_VERSION = 116
-PATCH_VERSION = "2"
+PATCH_VERSION = "3"
 __short_version__ = f"{MAJOR_VERSION}.{MINOR_VERSION}"
 __version__ = f"{__short_version__}.{PATCH_VERSION}"
 REQUIRED_PYTHON_VER = (3, 7, 1)

From b2f50d0a3ac7b10e57f658f1953d6c18ff7cd60d Mon Sep 17 00:00:00 2001
From: Pascal Vizeli <pvizeli@syshack.ch>
Date: Thu, 15 Oct 2020 13:34:27 +0200
Subject: [PATCH 78/82] Fix machine release builds (#41879)

---
 azure-pipelines-release.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/azure-pipelines-release.yml b/azure-pipelines-release.yml
index 6bca099d9ad..4668e62892a 100644
--- a/azure-pipelines-release.yml
+++ b/azure-pipelines-release.yml
@@ -118,7 +118,7 @@ stages:
           -v $(pwd):/data:ro \
           homeassistant/amd64-builder:$(versionBuilder) \
           --homeassistant-machine "$(homeassistantRelease)=$(buildMachine)" \
-          -t /data --docker-hub homeassistant
+          -t /data/machine --docker-hub homeassistant
       displayName: 'Build Release'
 
 - stage: 'Publish'

From 0323aeb660bb2a9a391eefaab5a698b3bdd221d8 Mon Sep 17 00:00:00 2001
From: Pascal Vizeli <pvizeli@syshack.ch>
Date: Thu, 15 Oct 2020 13:34:27 +0200
Subject: [PATCH 79/82] Fix machine release builds (#41879)

---
 azure-pipelines-release.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/azure-pipelines-release.yml b/azure-pipelines-release.yml
index 6bca099d9ad..4668e62892a 100644
--- a/azure-pipelines-release.yml
+++ b/azure-pipelines-release.yml
@@ -118,7 +118,7 @@ stages:
           -v $(pwd):/data:ro \
           homeassistant/amd64-builder:$(versionBuilder) \
           --homeassistant-machine "$(homeassistantRelease)=$(buildMachine)" \
-          -t /data --docker-hub homeassistant
+          -t /data/machine --docker-hub homeassistant
       displayName: 'Build Release'
 
 - stage: 'Publish'

From 303b7efd4bae9ef6414cfcad6263ddfdea1ec452 Mon Sep 17 00:00:00 2001
From: Jason Hunter <hunterjm@gmail.com>
Date: Thu, 15 Oct 2020 16:24:33 -0400
Subject: [PATCH 80/82] Bump ONVIF and pin Zeep (#41907)

---
 homeassistant/components/onvif/manifest.json | 6 +++++-
 requirements_all.txt                         | 5 ++++-
 requirements_test_all.txt                    | 5 ++++-
 3 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/homeassistant/components/onvif/manifest.json b/homeassistant/components/onvif/manifest.json
index 182fe22d60c..5b12d1624b9 100644
--- a/homeassistant/components/onvif/manifest.json
+++ b/homeassistant/components/onvif/manifest.json
@@ -2,7 +2,11 @@
   "domain": "onvif",
   "name": "ONVIF",
   "documentation": "https://www.home-assistant.io/integrations/onvif",
-  "requirements": ["onvif-zeep-async==0.5.0", "WSDiscovery==2.0.0"],
+  "requirements": [
+    "onvif-zeep-async==0.6.0",
+    "WSDiscovery==2.0.0",
+    "zeep[async]==3.4.0"
+  ],
   "dependencies": ["ffmpeg"],
   "codeowners": ["@hunterjm"],
   "config_flow": true
diff --git a/requirements_all.txt b/requirements_all.txt
index 003e87213bc..d5c1cdff86d 100644
--- a/requirements_all.txt
+++ b/requirements_all.txt
@@ -1022,7 +1022,7 @@ omnilogic==0.4.0
 onkyo-eiscp==1.2.7
 
 # homeassistant.components.onvif
-onvif-zeep-async==0.5.0
+onvif-zeep-async==0.6.0
 
 # homeassistant.components.opengarage
 open-garage==0.1.4
@@ -2303,6 +2303,9 @@ yeelightsunflower==0.0.10
 # homeassistant.components.media_extractor
 youtube_dl==2020.09.20
 
+# homeassistant.components.onvif
+zeep[async]==3.4.0
+
 # homeassistant.components.zengge
 zengge==0.2
 
diff --git a/requirements_test_all.txt b/requirements_test_all.txt
index 3b1b13fa1a8..ba81a6c0a49 100644
--- a/requirements_test_all.txt
+++ b/requirements_test_all.txt
@@ -490,7 +490,7 @@ oauth2client==4.0.0
 omnilogic==0.4.0
 
 # homeassistant.components.onvif
-onvif-zeep-async==0.5.0
+onvif-zeep-async==0.6.0
 
 # homeassistant.components.openerz
 openerz-api==0.1.0
@@ -1066,6 +1066,9 @@ xmltodict==0.12.0
 # homeassistant.components.yeelight
 yeelight==0.5.4
 
+# homeassistant.components.onvif
+zeep[async]==3.4.0
+
 # homeassistant.components.zeroconf
 zeroconf==0.28.5
 

From 36a1fe5f54468d78628f3fdb1e0057ae2c8d3ff5 Mon Sep 17 00:00:00 2001
From: Paulus Schoutsen <balloob@gmail.com>
Date: Thu, 15 Oct 2020 20:30:57 +0000
Subject: [PATCH 81/82] Bumped version to 0.116.4

---
 homeassistant/const.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/homeassistant/const.py b/homeassistant/const.py
index a3ed164ecba..ec54d017962 100644
--- a/homeassistant/const.py
+++ b/homeassistant/const.py
@@ -1,7 +1,7 @@
 """Constants used by Home Assistant components."""
 MAJOR_VERSION = 0
 MINOR_VERSION = 116
-PATCH_VERSION = "3"
+PATCH_VERSION = "4"
 __short_version__ = f"{MAJOR_VERSION}.{MINOR_VERSION}"
 __version__ = f"{__short_version__}.{PATCH_VERSION}"
 REQUIRED_PYTHON_VER = (3, 7, 1)

From a72dd6b91723961818ec3b3321c226d3c4a1b308 Mon Sep 17 00:00:00 2001
From: uvjustin <46082645+uvjustin@users.noreply.github.com>
Date: Fri, 16 Oct 2020 04:37:27 +0800
Subject: [PATCH 82/82] Cap AVC profile level at 4.1 in stream master playlist
 (#41592)

* Cap AVC profile level at 4.1

* Use smaller multiplier in bandwidth calculation
---
 homeassistant/components/stream/fmp4utils.py | 3 ++-
 homeassistant/components/stream/hls.py       | 5 +++--
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/homeassistant/components/stream/fmp4utils.py b/homeassistant/components/stream/fmp4utils.py
index dc929e531c1..1838b3fc88b 100644
--- a/homeassistant/components/stream/fmp4utils.py
+++ b/homeassistant/components/stream/fmp4utils.py
@@ -70,7 +70,8 @@ def get_codec_string(segment: io.BytesIO) -> str:
         ):
             profile = stsd_box[111:112].hex()
             compatibility = stsd_box[112:113].hex()
-            level = stsd_box[113:114].hex()
+            # Cap level at 4.1 for compatibility with some Google Cast devices
+            level = hex(min(stsd_box[113], 41))[2:]
             codec += "." + profile + compatibility + level
 
         # Handle H265
diff --git a/homeassistant/components/stream/hls.py b/homeassistant/components/stream/hls.py
index 09729f79ada..92801c4807f 100644
--- a/homeassistant/components/stream/hls.py
+++ b/homeassistant/components/stream/hls.py
@@ -32,10 +32,11 @@ class HlsMasterPlaylistView(StreamView):
     def render(track):
         """Render M3U8 file."""
         # Need to calculate max bandwidth as input_container.bit_rate doesn't seem to work
-        # Calculate file size / duration and use a multiplier to account for variation
+        # Calculate file size / duration and use a small multiplier to account for variation
+        # hls spec already allows for 25% variation
         segment = track.get_segment(track.segments[-1])
         bandwidth = round(
-            segment.segment.seek(0, io.SEEK_END) * 8 / segment.duration * 3
+            segment.segment.seek(0, io.SEEK_END) * 8 / segment.duration * 1.2
         )
         codecs = get_codec_string(segment.segment)
         lines = [