Use the ReadableBuffer type in more places (#4245)

This is a follow-up on #4232. memoryview, hashlib, and hmac are updated
to use ReadableBuffer type instead of their own home-spun unions of
bytes, bytearray and whatever else each use case used. mmap is being
handled in #4244, and I'll leave BinaryIO for another day (or possibly
another person) because it's going to require some messy code
duplication because the relevant methods are defined in IO[AnyStr].

There's one corner case I'm not quite sure how best to handle: the
documentation for hmac.digest claim that the parmaeters have the same
meanings as in hmac.new, but in CPython the latter has an explicit check
that `key` is bytes or bytearray while the former works with a
memory-view. For now I've matched the documentation.

Also, the documentation for HMAC.update says that `msg` can be any type
supported by hashlib from Python 3.4; but I can't see anything in the
Python 2.7 implementation that would prevent it also taking bytes-like
objects, so I've not tried to treat Python 2 any different to Python 3.

stdlib/2and3/hmac.pyi

@@ -3,28 +3,29 @@
 from typing import Any, AnyStr, Callable, Optional, Union, overload
 from types import ModuleType
 import sys
+from _typeshed import ReadableBuffer
 
 _B = Union[bytes, bytearray]
 
 # TODO more precise type for object of hashlib
 _Hash = Any
+_DigestMod = Union[str, Callable[[], _Hash], ModuleType]
 
 digest_size: None
 
 if sys.version_info >= (3, 8):
-    _DigestMod = Union[str, Callable[[], _Hash], ModuleType]
     # In reality digestmod has a default value, but the function always throws an error
     # if the argument is not given, so we pretend it is a required argument.
     @overload
-    def new(key: _B, msg: Optional[_B], digestmod: _DigestMod) -> HMAC: ...
+    def new(key: _B, msg: Optional[ReadableBuffer], digestmod: _DigestMod) -> HMAC: ...
     @overload
     def new(key: _B, *, digestmod: _DigestMod) -> HMAC: ...
 elif sys.version_info >= (3, 4):
-    def new(key: _B, msg: Optional[_B] = ...,
-            digestmod: Optional[Union[str, Callable[[], _Hash], ModuleType]] = ...) -> HMAC: ...
+    def new(key: _B, msg: Optional[ReadableBuffer] = ...,
+            digestmod: Optional[_DigestMod] = ...) -> HMAC: ...
 else:
-    def new(key: _B, msg: Optional[_B] = ...,
-            digestmod: Optional[Union[Callable[[], _Hash], ModuleType]] = ...) -> HMAC: ...
+    def new(key: _B, msg: Optional[ReadableBuffer] = ...,
+            digestmod: Optional[_DigestMod] = ...) -> HMAC: ...
 
 class HMAC:
     if sys.version_info >= (3,):
@@ -32,15 +33,15 @@ class HMAC:
     if sys.version_info >= (3, 4):
         block_size: int
         name: str
-    def update(self, msg: _B) -> None: ...
+    def update(self, msg: ReadableBuffer) -> None: ...
     def digest(self) -> bytes: ...
     def hexdigest(self) -> str: ...
     def copy(self) -> HMAC: ...
 
 @overload
-def compare_digest(a: bytearray, b: bytearray) -> bool: ...
+def compare_digest(a: ReadableBuffer, b: ReadableBuffer) -> bool: ...
 @overload
 def compare_digest(a: AnyStr, b: AnyStr) -> bool: ...
 
 if sys.version_info >= (3, 7):
-    def digest(key: _B, msg: _B, digest: str) -> bytes: ...
+    def digest(key: _B, msg: ReadableBuffer, digest: str) -> bytes: ...