Made local type vars in stubs private

stubs/2.7/typing.py

@@ -39,9 +39,9 @@ def __getitem__(self, typeargs):
 
 # Abstract base classes.
 
-T = typevar('T')
-KT = typevar('KT')
-VT = typevar('VT')
+_T = typevar('_T')
+_KT = typevar('_KT')
+_VT = typevar('_VT')
 
 # TODO Container etc.
 
@@ -53,113 +53,113 @@ class SupportsFloat(metaclass=ABCMeta):
     @abstractmethod
     def __float__(self) -> float: pass
 
-class SupportsAbs(AbstractGeneric[T]):
+class SupportsAbs(AbstractGeneric[_T]):
     @abstractmethod
-    def __abs__(self) -> T: pass
+    def __abs__(self) -> _T: pass
 
 @disjointclass(int)
 @disjointclass(float)
-class SupportsRound(AbstractGeneric[T]):
+class SupportsRound(AbstractGeneric[_T]):
     @abstractmethod
-    def __round__(self, ndigits: int = 0) -> T: pass
+    def __round__(self, ndigits: int = 0) -> _T: pass
 
-class Reversible(AbstractGeneric[T]):
+class Reversible(AbstractGeneric[_T]):
     @abstractmethod
-    def __reversed__(self) -> Iterator[T]: pass
+    def __reversed__(self) -> Iterator[_T]: pass
 
 class Sized(metaclass=ABCMeta):
     @abstractmethod
     def __len__(self) -> int: pass
 
-class Iterable(AbstractGeneric[T]):
+class Iterable(AbstractGeneric[_T]):
     @abstractmethod
-    def __iter__(self) -> Iterator[T]: pass
+    def __iter__(self) -> Iterator[_T]: pass
 
-class Iterator(Iterable[T], AbstractGeneric[T]):
+class Iterator(Iterable[_T], AbstractGeneric[_T]):
     @abstractmethod
-    def next(self) -> T: pass
+    def next(self) -> _T: pass
 
-class Sequence(Sized, Iterable[T], AbstractGeneric[T]):
+class Sequence(Sized, Iterable[_T], AbstractGeneric[_T]):
     @abstractmethod
     def __contains__(self, x: object) -> bool: pass
     @overload
     @abstractmethod
-    def __getitem__(self, i: int) -> T: pass
+    def __getitem__(self, i: int) -> _T: pass
     @overload
     @abstractmethod
-    def __getitem__(self, s: slice) -> Sequence[T]: pass
+    def __getitem__(self, s: slice) -> Sequence[_T]: pass
 
-class AbstractSet(Sized, Iterable[T], AbstractGeneric[T]):
+class AbstractSet(Sized, Iterable[_T], AbstractGeneric[_T]):
     @abstractmethod
     def __contains__(self, x: object) -> bool: pass
     # TODO __le__, __lt__, __gt__, __ge__
     @abstractmethod
-    def __and__(self, s: AbstractSet[T]) -> AbstractSet[T]: pass
+    def __and__(self, s: AbstractSet[_T]) -> AbstractSet[_T]: pass
     @abstractmethod
-    def __or__(self, s: AbstractSet[T]) -> AbstractSet[T]: pass
+    def __or__(self, s: AbstractSet[_T]) -> AbstractSet[_T]: pass
     @abstractmethod
-    def __sub__(self, s: AbstractSet[T]) -> AbstractSet[T]: pass
+    def __sub__(self, s: AbstractSet[_T]) -> AbstractSet[_T]: pass
     @abstractmethod
-    def __xor__(self, s: AbstractSet[T]) -> AbstractSet[T]: pass
+    def __xor__(self, s: AbstractSet[_T]) -> AbstractSet[_T]: pass
     # TODO argument can be any container?
     @abstractmethod
-    def isdisjoint(self, s: AbstractSet[T]) -> bool: pass
+    def isdisjoint(self, s: AbstractSet[_T]) -> bool: pass
 
-class Mapping(Sized, Iterable[KT], AbstractGeneric[KT, VT]):
+class Mapping(Sized, Iterable[_KT], AbstractGeneric[_KT, _VT]):
     @abstractmethod
-    def __getitem__(self, k: KT) -> VT: pass
+    def __getitem__(self, k: _KT) -> _VT: pass
     @abstractmethod
-    def __setitem__(self, k: KT, v: VT) -> None: pass
+    def __setitem__(self, k: _KT, v: _VT) -> None: pass
     @abstractmethod
-    def __delitem__(self, v: KT) -> None: pass
+    def __delitem__(self, v: _KT) -> None: pass
     @abstractmethod
     def __contains__(self, o: object) -> bool: pass
 
     @abstractmethod
     def clear(self) -> None: pass
     @abstractmethod
-    def copy(self) -> Mapping[KT, VT]: pass
+    def copy(self) -> Mapping[_KT, _VT]: pass
     @overload
     @abstractmethod
-    def get(self, k: KT) -> VT: pass
+    def get(self, k: _KT) -> _VT: pass
     @overload
     @abstractmethod
-    def get(self, k: KT, default: VT) -> VT: pass
+    def get(self, k: _KT, default: _VT) -> _VT: pass
     @overload
     @abstractmethod
-    def pop(self, k: KT) -> VT: pass
+    def pop(self, k: _KT) -> _VT: pass
     @overload
     @abstractmethod
-    def pop(self, k: KT, default: VT) -> VT: pass
+    def pop(self, k: _KT, default: _VT) -> _VT: pass
     @abstractmethod
-    def popitem(self) -> Tuple[KT, VT]: pass
+    def popitem(self) -> Tuple[_KT, _VT]: pass
     @overload
     @abstractmethod
-    def setdefault(self, k: KT) -> VT: pass
+    def setdefault(self, k: _KT) -> _VT: pass
     @overload
     @abstractmethod
-    def setdefault(self, k: KT, default: VT) -> VT: pass
+    def setdefault(self, k: _KT, default: _VT) -> _VT: pass
 
     # TODO keyword arguments
     @overload
     @abstractmethod
-    def update(self, m: Mapping[KT, VT]) -> None: pass
+    def update(self, m: Mapping[_KT, _VT]) -> None: pass
     @overload
     @abstractmethod
-    def update(self, m: Iterable[Tuple[KT, VT]]) -> None: pass
+    def update(self, m: Iterable[Tuple[_KT, _VT]]) -> None: pass
 
     @abstractmethod
-    def keys(self) -> list[KT]: pass
+    def keys(self) -> list[_KT]: pass
     @abstractmethod
-    def values(self) -> list[VT]: pass
+    def values(self) -> list[_VT]: pass
     @abstractmethod
-    def items(self) -> list[Tuple[KT, VT]]: pass
+    def items(self) -> list[Tuple[_KT, _VT]]: pass
     @abstractmethod
-    def iterkeys(self) -> Iterator[KT]: pass
+    def iterkeys(self) -> Iterator[_KT]: pass
     @abstractmethod
-    def itervalues(self) -> Iterator[VT]: pass
+    def itervalues(self) -> Iterator[_VT]: pass
     @abstractmethod
-    def iteritems(self) -> Iterator[Tuple[KT, VT]]: pass
+    def iteritems(self) -> Iterator[Tuple[_KT, _VT]]: pass
 
 class IO(Iterable[AnyStr], AbstractGeneric[AnyStr]):
     # TODO detach

stubs/3.2/atexit.py

@@ -1,5 +1,5 @@
 from typing import typevar, Any
 
-FT = typevar('FT')
+_FT = typevar('_FT')
 
-def register(func: FT, *args: Any, **kargs: Any) -> FT: pass
+def register(func: _FT, *args: Any, **kargs: Any) -> _FT: pass

stubs/3.2/collections.py

@@ -13,87 +13,87 @@
     Mapping, List, Tuple, Undefined, Function, Set, Sequence, Sized
 )
 
-T = typevar('T')
-KT = typevar('KT')
-VT = typevar('VT')
+_T = typevar('_T')
+_KT = typevar('_KT')
+_VT = typevar('_VT')
 
 
-class deque(Sized, Iterable[T], AbstractGeneric[T]):
+class deque(Sized, Iterable[_T], AbstractGeneric[_T]):
     # TODO int with None default
     maxlen = 0 # TODO readonly
-    def __init__(self, iterable: Iterable[T] = None,
+    def __init__(self, iterable: Iterable[_T] = None,
                  maxlen: int = None) -> None: pass
-    def append(self, x: T) -> None: pass
-    def appendleft(self, x: T) -> None: pass
+    def append(self, x: _T) -> None: pass
+    def appendleft(self, x: _T) -> None: pass
     def clear(self) -> None: pass
-    def count(self, x: T) -> int: pass
-    def extend(self, iterable: Iterable[T]) -> None: pass
-    def extendleft(self, iterable: Iterable[T]) -> None: pass
-    def pop(self) -> T: pass
-    def popleft(self) -> T: pass
-    def remove(self, value: T) -> None: pass
+    def count(self, x: _T) -> int: pass
+    def extend(self, iterable: Iterable[_T]) -> None: pass
+    def extendleft(self, iterable: Iterable[_T]) -> None: pass
+    def pop(self) -> _T: pass
+    def popleft(self) -> _T: pass
+    def remove(self, value: _T) -> None: pass
     def reverse(self) -> None: pass
     def rotate(self, n: int) -> None: pass
 
     def __len__(self) -> int: pass
-    def __iter__(self) -> Iterator[T]: pass
+    def __iter__(self) -> Iterator[_T]: pass
     def __str__(self) -> str: pass
     def __hash__(self) -> int: pass
 
-    def __getitem__(self, i: int) -> T: pass
-    def __setitem__(self, i: int, x: T) -> None: pass
-    def __contains__(self, o: T) -> bool: pass
+    def __getitem__(self, i: int) -> _T: pass
+    def __setitem__(self, i: int, x: _T) -> None: pass
+    def __contains__(self, o: _T) -> bool: pass
 
     # TODO __reversed__
 
 
-class Counter(Dict[T, int], Generic[T]):
+class Counter(Dict[_T, int], Generic[_T]):
     @overload
     def __init__(self) -> None: pass
     @overload
-    def __init__(self, Mapping: Mapping[T, int]) -> None: pass
+    def __init__(self, Mapping: Mapping[_T, int]) -> None: pass
     @overload
-    def __init__(self, iterable: Iterable[T]) -> None: pass
+    def __init__(self, iterable: Iterable[_T]) -> None: pass
     # TODO keyword arguments
 
-    def elements(self) -> Iterator[T]: pass
+    def elements(self) -> Iterator[_T]: pass
 
     @overload
-    def most_common(self) -> List[T]: pass
+    def most_common(self) -> List[_T]: pass
     @overload
-    def most_common(self, n: int) -> List[T]: pass
+    def most_common(self, n: int) -> List[_T]: pass
 
     @overload
-    def subtract(self, Mapping: Mapping[T, int]) -> None: pass
+    def subtract(self, Mapping: Mapping[_T, int]) -> None: pass
     @overload
-    def subtract(self, iterable: Iterable[T]) -> None: pass
+    def subtract(self, iterable: Iterable[_T]) -> None: pass
 
     # TODO update
 
 
-class OrderedDict(Dict[KT, VT], Generic[KT, VT]):
-    def popitem(self, last: bool = True) -> Tuple[KT, VT]: pass
-    def move_to_end(self, key: KT, last: bool = True) -> None: pass
+class OrderedDict(Dict[_KT, _VT], Generic[_KT, _VT]):
+    def popitem(self, last: bool = True) -> Tuple[_KT, _VT]: pass
+    def move_to_end(self, key: _KT, last: bool = True) -> None: pass
 
 
-class defaultdict(Dict[KT, VT], Generic[KT, VT]):
-    default_factory = Undefined(Function[[], VT])
+class defaultdict(Dict[_KT, _VT], Generic[_KT, _VT]):
+    default_factory = Undefined(Function[[], _VT])
 
     @overload
     def __init__(self) -> None: pass
     @overload
-    def __init__(self, map: Mapping[KT, VT]) -> None: pass
+    def __init__(self, map: Mapping[_KT, _VT]) -> None: pass
     @overload
-    def __init__(self, iterable: Iterable[Tuple[KT, VT]]) -> None: pass
+    def __init__(self, iterable: Iterable[Tuple[_KT, _VT]]) -> None: pass
     @overload
-    def __init__(self, default_factory: Function[[], VT]) -> None: pass
+    def __init__(self, default_factory: Function[[], _VT]) -> None: pass
     @overload
-    def __init__(self, default_factory: Function[[], VT],
-                 map: Mapping[KT, VT]) -> None: pass
+    def __init__(self, default_factory: Function[[], _VT],
+                 map: Mapping[_KT, _VT]) -> None: pass
     @overload
-    def __init__(self, default_factory: Function[[], VT],
-                 iterable: Iterable[Tuple[KT, VT]]) -> None: pass
+    def __init__(self, default_factory: Function[[], _VT],
+                 iterable: Iterable[Tuple[_KT, _VT]]) -> None: pass
     # TODO __init__ keyword args
 
-    def __missing__(self, key: KT) -> VT: pass
+    def __missing__(self, key: _KT) -> _VT: pass
     # TODO __reversed__

stubs/3.2/copy.py

@@ -4,6 +4,6 @@
 
 from typing import typevar
 
-T = typevar('T')
+_T = typevar('_T')
 
-def deepcopy(x: T) -> T: pass
+def deepcopy(x: _T) -> _T: pass

stubs/3.2/heapq.py

@@ -4,15 +4,15 @@
 
 from typing import typevar, List, Iterable, Any, Function
 
-T = typevar('T')
+_T = typevar('_T')
 
-def heappush(heap: List[T], item: T) -> None: pass
-def heappop(heap: List[T]) -> T: pass
-def heappushpop(heap: List[T], item: T) -> T: pass
-def heapify(x: List[T]) -> None: pass
-def heapreplace(heap: List[T], item: T) -> T: pass
-def merge(*iterables: Iterable[T]) -> Iterable[T]: pass
-def nlargest(n: int, iterable: Iterable[T],
-             key: Function[[T], Any] = None) -> List[T]: pass
-def nsmallest(n: int, iterable: Iterable[T],
-              key: Function[[T], Any] = None) -> List[T]: pass
+def heappush(heap: List[_T], item: _T) -> None: pass
+def heappop(heap: List[_T]) -> _T: pass
+def heappushpop(heap: List[_T], item: _T) -> _T: pass
+def heapify(x: List[_T]) -> None: pass
+def heapreplace(heap: List[_T], item: _T) -> _T: pass
+def merge(*iterables: Iterable[_T]) -> Iterable[_T]: pass
+def nlargest(n: int, iterable: Iterable[_T],
+             key: Function[[_T], Any] = None) -> List[_T]: pass
+def nsmallest(n: int, iterable: Iterable[_T],
+              key: Function[[_T], Any] = None) -> List[_T]: pass

stubs/3.2/imp.py

@@ -4,7 +4,7 @@
 
 from typing import typevar
 
-T = typevar('T')
+_T = typevar('_T')
 
 def cache_from_source(path: str, debug_override: bool = None) -> str: pass
-def reload(module: T) -> T: pass # TODO imprecise signature
+def reload(module: _T) -> _T: pass # TODO imprecise signature