类型注释进化篇

def _tp_cache(func=None, , *, typed=False):
    """Internal wrapper caching __getitem__ of generic types with a fallback to
    original function for non-hashable arguments.
    """
    def decorator(func):
        cached = functools.lru_cache(typed=typed)(func)
        _cleanups.append(cached.cache_clear)


        @functools.wraps(func)
        def inner(*args, **kwds):
            try:
                return cached(*args, **kwds)
            except TypeError:
                pass  # All real errors (not unhashable args) are raised below.
            return func(*args, **kwds)
        return inner


    if func is not None:
        return decorator(func)


    return decorator
    
class _Final:
    "
    ""Mixin to prohibit subclassing"""


    __slots__ = ('__weakref__',)


    def __init_subclass__(self, , *args, **kwds):
        if '_root' not in kwds:
            raise TypeError("Cannot subclass special typing classes")
            
class _SpecialForm(_Final, _root=True):
    __slots__ = ('_name', '__doc__', '_getitem')


    def __init__(self, getitem):
        self._getitem = getitem
        self._name = getitem.__name__
        self.__doc__ = getitem.__doc__


    def __mro_entries__(self, bases):
        raise TypeError(f"Cannot subclass {self!r}")


    def __repr__(self):
        return 'typing.' + self._name


    def __reduce__(self):
        return self._name


    def __call__(self, *args, **kwds):
        raise TypeError(f"Cannot instantiate {self!r}")


    def __instancecheck__(self, obj):
        raise TypeError(f"{self} cannot be used with isinstance()")


    def __subclasscheck__(self, cls):
        raise TypeError(f"{self} cannot be used with issubclass()")


    @_tp_cache
    def __getitem__(self, parameters):
        return self._getitem(self, parameters)

@_SpecialForm
def Final(self, parameters):
    """Special typing construct to indicate final names to type checkers.


    A final name cannot be re-assigned or overridden in a subclass.
    For example:


      MAX_SIZE: Final = 9000
      MAX_SIZE += 1  # Error reported by type checker


      class Connection:
          TIMEOUT: Final[int] = 10


      class FastConnector(Connection):
          TIMEOUT = 1  # Error reported by type checker


    There is no runtime checking of these properties.
    """
    item = _type_check(parameters, f'{self} accepts only single type.')
    return _GenericAlias(self, (item,))

 Base class for protocol classes.


    Protocol classes are defined as::


        class Proto(Protocol):
            def meth(self) -> int:
                ...


    Such classes are primarily used with static type checkers that recognize
    structural subtyping (static duck-typing), for example::


        class C:
            def meth(self) -> int:
                return 0


        def func(x: Proto) -> int:
            return x.meth()


        func(C())  # Passes static type check

A generic type is typically declared by inheriting from
    this class parameterized with one or more type variables.
    For example, a generic mapping type might be defined as::


      class Mapping(Generic[KT, VT]):
          def __getitem__(self, key: KT) -> VT:
              ...
          # Etc.


    This class can then be used as follows::


      def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
          try:
              return mapping[key]
          except KeyError:
              return default