TYP: Simplify LazyImporter.imports annotations

Author: Bas van Beek

nanoutils/_lazy_import.py

@@ -14,26 +14,15 @@
 import reprlib
 import importlib
 from collections.abc import Mapping, Callable, Iterable
-from typing import Any, TypeVar, Type, Generic, cast, TYPE_CHECKING
+from typing import Any, TypeVar, Type, Generic, TYPE_CHECKING
 
 _T = TypeVar("_T")
 
 if TYPE_CHECKING:
     from typing_extensions import Protocol
-    from typing import (
-        overload,
-        Collection,
-        Union,
-        Tuple,
-        Dict,
-        KeysView,
-        ValuesView,
-        ItemsView,
-        Iterator,
-    )
+    from typing import Union, Tuple, Dict
 
     _KT = TypeVar("_KT")
-    _VT = TypeVar("_VT")
     _VT_co = TypeVar("_VT_co", covariant=True)
     _ST1 = TypeVar("_ST1", bound="LazyImporter[Any]")
     _ST2 = TypeVar("_ST2", bound="MutableLazyImporter[Any]")
@@ -42,26 +31,6 @@ class _SupportsKeysAndGetItem(Protocol[_KT, _VT_co]):
         def __getitem__(self, __key: _KT) -> _VT_co: ...
         def keys(self) -> Iterable[_KT]: ...
 
-    # A `Protocol` version of `types.MappingProxyType`
-    class _MappingProtocol(Protocol[_KT, _VT], Collection[_KT]):
-        __hash__: None  # type: ignore
-        def __getitem__(self, k: _KT) -> _VT: ...
-        def __contains__(self, o: object) -> bool: ...
-        @overload
-        def get(self, key: _KT) -> None | _VT: ...
-        @overload
-        def get(self, key: _KT, default: _T) -> _T | _VT: ...
-        def items(self) -> ItemsView[_KT, _VT]: ...
-        def keys(self) -> KeysView[_KT]: ...
-        def values(self) -> ValuesView[_VT]: ...
-        def copy(self) -> dict[_KT, _VT]: ...
-
-        # TODO: Update `__or__` once mypy > 0.910 hits
-        if sys.version_info >= (3, 9):
-            def __reversed__(self) -> Iterator[_KT]: ...
-            def __or__(self, __value: Mapping[_KT, _VT]) -> dict[_KT, _VT]: ...
-            def __ror__(self, __value: Mapping[_KT, _VT]) -> dict[_KT, _VT]: ...
-
     _DictLike = Union[_SupportsKeysAndGetItem[str, str], Iterable[Tuple[str, str]]]
     _ReduceTuple = Tuple[Callable[[str, Dict[str, str]], _T], Tuple[str, Dict[str, str]]]
 
@@ -114,7 +83,7 @@ def module(self) -> types.ModuleType:
         return self._module
 
     @property
-    def imports(self) -> _MappingProtocol[str, str]:
+    def imports(self) -> Mapping[str, str]:
         """:class:`types.MappingProxyType[str, str]<types.MappingProxyType>`: Get a mapping that maps object names to their module name."""  # noqa: E501
         return self._imports
 
@@ -127,7 +96,7 @@ def __init__(
         if not isinstance(module, types.ModuleType):
             raise TypeError(f"Expected a module, not {type(module).__name__}")
         self._module = module
-        self._imports = cast("_MappingProtocol[str, str]", types.MappingProxyType(dict(imports)))
+        self._imports: Mapping[str, str] = types.MappingProxyType(dict(imports))
 
     @classmethod
     def from_name(cls: Type[_ST1], name: str, imports: _DictLike) -> _ST1:
@@ -158,7 +127,7 @@ def from_name(cls: Type[_ST1], name: str, imports: _DictLike) -> _ST1:
     def __reduce__(self: _ST1) -> _ReduceTuple[_ST1]:
         """Helper for :mod:`pickle`."""
         cls = type(self)
-        args = (self.module.__name__, self.imports.copy())
+        args = (self.module.__name__, self.imports.copy())  # type: ignore[attr-defined]
         return cls.from_name, args
 
     def __copy__(self: _ST1) -> _ST1:
@@ -179,8 +148,7 @@ def __hash__(self) -> int:
 
     def __eq__(self, value: object) -> bool:
         """Implement :meth:`self == value<object.__eq__>`."""
-        cls = type(self)
-        if not isinstance(value, cls):
+        if not isinstance(value, LazyImporter):
             return NotImplemented
         return self.module is value.module and self.imports == value.imports