Add typing to homeassistant/*.py and homeassistant/util/ (#15569)

* Add typing to homeassistant/*.py and homeassistant/util/

* Fix wrong merge

* Restore iterable in OrderedSet

* Fix tests

homeassistant/util/logging.py

@@ -1,7 +1,9 @@
 """Logging utilities."""
 import asyncio
+from asyncio.events import AbstractEventLoop
 import logging
 import threading
+from typing import Optional
 
 from .async_ import run_coroutine_threadsafe
 
@@ -9,12 +11,12 @@ from .async_ import run_coroutine_threadsafe
 class HideSensitiveDataFilter(logging.Filter):
     """Filter API password calls."""
 
-    def __init__(self, text):
+    def __init__(self, text: str) -> None:
         """Initialize sensitive data filter."""
         super().__init__()
         self.text = text
 
-    def filter(self, record):
+    def filter(self, record: logging.LogRecord) -> bool:
         """Hide sensitive data in messages."""
         record.msg = record.msg.replace(self.text, '*******')
 
@@ -25,7 +27,8 @@ class HideSensitiveDataFilter(logging.Filter):
 class AsyncHandler:
     """Logging handler wrapper to add an async layer."""
 
-    def __init__(self, loop, handler):
+    def __init__(
+            self, loop: AbstractEventLoop, handler: logging.Handler) -> None:
         """Initialize async logging handler wrapper."""
         self.handler = handler
         self.loop = loop
@@ -45,11 +48,11 @@ class AsyncHandler:
 
         self._thread.start()
 
-    def close(self):
+    def close(self) -> None:
         """Wrap close to handler."""
         self.emit(None)
 
-    async def async_close(self, blocking=False):
+    async def async_close(self, blocking: bool = False) -> None:
         """Close the handler.
 
         When blocking=True, will wait till closed.
@@ -60,7 +63,7 @@ class AsyncHandler:
             while self._thread.is_alive():
                 await asyncio.sleep(0, loop=self.loop)
 
-    def emit(self, record):
+    def emit(self, record: Optional[logging.LogRecord]) -> None:
         """Process a record."""
         ident = self.loop.__dict__.get("_thread_ident")
 
@@ -71,11 +74,11 @@ class AsyncHandler:
         else:
             self.loop.call_soon_threadsafe(self._queue.put_nowait, record)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         """Return the string names."""
         return str(self.handler)
 
-    def _process(self):
+    def _process(self) -> None:
         """Process log in a thread."""
         while True:
             record = run_coroutine_threadsafe(
@@ -87,34 +90,34 @@ class AsyncHandler:
 
             self.handler.emit(record)
 
-    def createLock(self):
+    def createLock(self) -> None:
         """Ignore lock stuff."""
         pass
 
-    def acquire(self):
+    def acquire(self) -> None:
         """Ignore lock stuff."""
         pass
 
-    def release(self):
+    def release(self) -> None:
         """Ignore lock stuff."""
         pass
 
     @property
-    def level(self):
+    def level(self) -> int:
         """Wrap property level to handler."""
         return self.handler.level
 
     @property
-    def formatter(self):
+    def formatter(self) -> Optional[logging.Formatter]:
         """Wrap property formatter to handler."""
         return self.handler.formatter
 
     @property
-    def name(self):
+    def name(self) -> str:
         """Wrap property set_name to handler."""
-        return self.handler.get_name()
+        return self.handler.get_name()  # type: ignore
 
     @name.setter
-    def name(self, name):
+    def name(self, name: str) -> None:
         """Wrap property get_name to handler."""
-        self.handler.name = name
+        self.handler.set_name(name)  # type: ignore