apply black and isort (#4287)

* apply black and isort

* move some type ignores

stdlib/3/unittest/__init__.pyi

@@ -1,7 +1,6 @@
 # Stubs for unittest
 
 from typing import Optional
-
 from unittest.async_case import *
 from unittest.case import *
 from unittest.loader import *
@@ -11,5 +10,4 @@ from unittest.runner import *
 from unittest.signals import *
 from unittest.suite import *
 
-def load_tests(loader: TestLoader, tests: TestSuite,
-               pattern: Optional[str]) -> TestSuite: ...
+def load_tests(loader: TestLoader, tests: TestSuite, pattern: Optional[str]) -> TestSuite: ...

stdlib/3/unittest/async_case.pyi

@@ -1,5 +1,6 @@
 import sys
 from typing import Any, Awaitable, Callable
+
 from .case import TestCase
 
 if sys.version_info >= (3, 8):

stdlib/3/unittest/case.pyi

@@ -5,13 +5,31 @@ import unittest.result
 import warnings
 from types import TracebackType
 from typing import (
-    Any, AnyStr, Callable, Container, ContextManager, Dict, FrozenSet, Generic,
-    Iterable, List, Mapping, NoReturn, Optional, overload, Pattern, Sequence,
-    Set, Tuple, Type, TypeVar, Union,
+    Any,
+    AnyStr,
+    Callable,
+    Container,
+    ContextManager,
+    Dict,
+    FrozenSet,
+    Generic,
+    Iterable,
+    List,
+    Mapping,
+    NoReturn,
+    Optional,
+    Pattern,
+    Sequence,
+    Set,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    overload,
 )
 
-_E = TypeVar('_E', bound=BaseException)
-_FT = TypeVar('_FT', bound=Callable[..., Any])
+_E = TypeVar("_E", bound=BaseException)
+_FT = TypeVar("_FT", bound=Callable[..., Any])
 
 if sys.version_info >= (3, 8):
     def addModuleCleanup(__function: Callable[..., Any], *args: Any, **kwargs: Any) -> None: ...
@@ -22,11 +40,9 @@ def skip(reason: str) -> Callable[[_FT], _FT]: ...
 def skipIf(condition: object, reason: str) -> Callable[[_FT], _FT]: ...
 def skipUnless(condition: object, reason: str) -> Callable[[_FT], _FT]: ...
 
-
 class SkipTest(Exception):
     def __init__(self, reason: str) -> None: ...
 
-
 class TestCase:
     failureException: Type[BaseException]
     longMessage: bool
@@ -47,132 +63,133 @@ class TestCase:
     def skipTest(self, reason: Any) -> None: ...
     def subTest(self, msg: Any = ..., **params: Any) -> ContextManager[None]: ...
     def debug(self) -> None: ...
-    def _addSkip(
-        self, result: unittest.result.TestResult, test_case: unittest.case.TestCase, reason: str
-    ) -> None: ...
+    def _addSkip(self, result: unittest.result.TestResult, test_case: unittest.case.TestCase, reason: str) -> None: ...
     def assertEqual(self, first: Any, second: Any, msg: Any = ...) -> None: ...
-    def assertNotEqual(self, first: Any, second: Any,
-                       msg: Any = ...) -> None: ...
+    def assertNotEqual(self, first: Any, second: Any, msg: Any = ...) -> None: ...
     def assertTrue(self, expr: Any, msg: Any = ...) -> None: ...
     def assertFalse(self, expr: Any, msg: Any = ...) -> None: ...
     def assertIs(self, expr1: Any, expr2: Any, msg: Any = ...) -> None: ...
     def assertIsNot(self, expr1: Any, expr2: Any, msg: Any = ...) -> None: ...
     def assertIsNone(self, obj: Any, msg: Any = ...) -> None: ...
     def assertIsNotNone(self, obj: Any, msg: Any = ...) -> None: ...
-    def assertIn(self, member: Any,
-                 container: Union[Iterable[Any], Container[Any]],
-                 msg: Any = ...) -> None: ...
-    def assertNotIn(self, member: Any,
-                    container: Union[Iterable[Any], Container[Any]],
-                    msg: Any = ...) -> None: ...
-    def assertIsInstance(self, obj: Any,
-                         cls: Union[type, Tuple[type, ...]],
-                         msg: Any = ...) -> None: ...
-    def assertNotIsInstance(self, obj: Any,
-                            cls: Union[type, Tuple[type, ...]],
-                            msg: Any = ...) -> None: ...
+    def assertIn(self, member: Any, container: Union[Iterable[Any], Container[Any]], msg: Any = ...) -> None: ...
+    def assertNotIn(self, member: Any, container: Union[Iterable[Any], Container[Any]], msg: Any = ...) -> None: ...
+    def assertIsInstance(self, obj: Any, cls: Union[type, Tuple[type, ...]], msg: Any = ...) -> None: ...
+    def assertNotIsInstance(self, obj: Any, cls: Union[type, Tuple[type, ...]], msg: Any = ...) -> None: ...
     def assertGreater(self, a: Any, b: Any, msg: Any = ...) -> None: ...
     def assertGreaterEqual(self, a: Any, b: Any, msg: Any = ...) -> None: ...
     def assertLess(self, a: Any, b: Any, msg: Any = ...) -> None: ...
     def assertLessEqual(self, a: Any, b: Any, msg: Any = ...) -> None: ...
     @overload
-    def assertRaises(self,  # type: ignore
-                     expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]],
-                     callable: Callable[..., Any],
-                     *args: Any, **kwargs: Any) -> None: ...
+    def assertRaises(  # type: ignore
+        self,
+        expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]],
+        callable: Callable[..., Any],
+        *args: Any,
+        **kwargs: Any,
+    ) -> None: ...
     @overload
-    def assertRaises(self,
-                     expected_exception: Union[Type[_E], Tuple[Type[_E], ...]],
-                     msg: Any = ...) -> _AssertRaisesContext[_E]: ...
+    def assertRaises(
+        self, expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any = ...
+    ) -> _AssertRaisesContext[_E]: ...
     @overload
-    def assertRaisesRegex(self,  # type: ignore
-                          expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]],
-                          expected_regex: Union[str, bytes, Pattern[str], Pattern[bytes]],
-                          callable: Callable[..., Any],
-                          *args: Any, **kwargs: Any) -> None: ...
+    def assertRaisesRegex(  # type: ignore
+        self,
+        expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]],
+        expected_regex: Union[str, bytes, Pattern[str], Pattern[bytes]],
+        callable: Callable[..., Any],
+        *args: Any,
+        **kwargs: Any,
+    ) -> None: ...
     @overload
-    def assertRaisesRegex(self,
-                          expected_exception: Union[Type[_E], Tuple[Type[_E], ...]],
-                          expected_regex: Union[str, bytes, Pattern[str], Pattern[bytes]],
-                          msg: Any = ...) -> _AssertRaisesContext[_E]: ...
+    def assertRaisesRegex(
+        self,
+        expected_exception: Union[Type[_E], Tuple[Type[_E], ...]],
+        expected_regex: Union[str, bytes, Pattern[str], Pattern[bytes]],
+        msg: Any = ...,
+    ) -> _AssertRaisesContext[_E]: ...
     @overload
-    def assertWarns(self,  # type: ignore
-                    expected_warning: Union[Type[Warning], Tuple[Type[Warning], ...]],
-                    callable: Callable[..., Any],
-                    *args: Any, **kwargs: Any) -> None: ...
+    def assertWarns(  # type: ignore
+        self,
+        expected_warning: Union[Type[Warning], Tuple[Type[Warning], ...]],
+        callable: Callable[..., Any],
+        *args: Any,
+        **kwargs: Any,
+    ) -> None: ...
     @overload
-    def assertWarns(self,
-                    expected_warning: Union[Type[Warning], Tuple[Type[Warning], ...]],
-                    msg: Any = ...) -> _AssertWarnsContext: ...
+    def assertWarns(
+        self, expected_warning: Union[Type[Warning], Tuple[Type[Warning], ...]], msg: Any = ...
+    ) -> _AssertWarnsContext: ...
     @overload
-    def assertWarnsRegex(self,  # type: ignore
-                         expected_warning: Union[Type[Warning], Tuple[Type[Warning], ...]],
-                         expected_regex: Union[str, bytes, Pattern[str], Pattern[bytes]],
-                         callable: Callable[..., Any],
-                         *args: Any, **kwargs: Any) -> None: ...
+    def assertWarnsRegex(  # type: ignore
+        self,
+        expected_warning: Union[Type[Warning], Tuple[Type[Warning], ...]],
+        expected_regex: Union[str, bytes, Pattern[str], Pattern[bytes]],
+        callable: Callable[..., Any],
+        *args: Any,
+        **kwargs: Any,
+    ) -> None: ...
     @overload
-    def assertWarnsRegex(self,
-                         expected_warning: Union[Type[Warning], Tuple[Type[Warning], ...]],
-                         expected_regex: Union[str, bytes, Pattern[str], Pattern[bytes]],
-                         msg: Any = ...) -> _AssertWarnsContext: ...
+    def assertWarnsRegex(
+        self,
+        expected_warning: Union[Type[Warning], Tuple[Type[Warning], ...]],
+        expected_regex: Union[str, bytes, Pattern[str], Pattern[bytes]],
+        msg: Any = ...,
+    ) -> _AssertWarnsContext: ...
     def assertLogs(
-        self, logger: Optional[Union[str, logging.Logger]] = ...,
-        level: Union[int, str, None] = ...
+        self, logger: Optional[Union[str, logging.Logger]] = ..., level: Union[int, str, None] = ...
     ) -> _AssertLogsContext: ...
     @overload
-    def assertAlmostEqual(self, first: float, second: float, places: Optional[int] = ...,
-                          msg: Any = ..., delta: Optional[float] = ...) -> None: ...
+    def assertAlmostEqual(
+        self, first: float, second: float, places: Optional[int] = ..., msg: Any = ..., delta: Optional[float] = ...
+    ) -> None: ...
     @overload
-    def assertAlmostEqual(self, first: datetime.datetime, second: datetime.datetime,
-                          places: Optional[int] = ..., msg: Any = ...,
-                          delta: Optional[datetime.timedelta] = ...) -> None: ...
+    def assertAlmostEqual(
+        self,
+        first: datetime.datetime,
+        second: datetime.datetime,
+        places: Optional[int] = ...,
+        msg: Any = ...,
+        delta: Optional[datetime.timedelta] = ...,
+    ) -> None: ...
     @overload
-    def assertNotAlmostEqual(self, first: float, second: float, *,
-                             msg: Any = ...) -> None: ...
+    def assertNotAlmostEqual(self, first: float, second: float, *, msg: Any = ...) -> None: ...
     @overload
-    def assertNotAlmostEqual(self, first: float, second: float,
-                             places: Optional[int] = ..., msg: Any = ...) -> None: ...
+    def assertNotAlmostEqual(self, first: float, second: float, places: Optional[int] = ..., msg: Any = ...) -> None: ...
     @overload
-    def assertNotAlmostEqual(self, first: float, second: float, *,
-                             msg: Any = ..., delta: Optional[float] = ...) -> None: ...
+    def assertNotAlmostEqual(self, first: float, second: float, *, msg: Any = ..., delta: Optional[float] = ...) -> None: ...
     @overload
-    def assertNotAlmostEqual(self, first: datetime.datetime, second: datetime.datetime,
-                             places: Optional[int] = ..., msg: Any = ...,
-                             delta: Optional[datetime.timedelta] = ...) -> None: ...
-    def assertRegex(self, text: AnyStr, expected_regex: Union[AnyStr, Pattern[AnyStr]],
-                    msg: Any = ...) -> None: ...
-    def assertNotRegex(self, text: AnyStr, unexpected_regex: Union[AnyStr, Pattern[AnyStr]],
-                       msg: Any = ...) -> None: ...
-    def assertCountEqual(self, first: Iterable[Any], second: Iterable[Any],
-                         msg: Any = ...) -> None: ...
-    def addTypeEqualityFunc(self, typeobj: Type[Any],
-                            function: Callable[..., None]) -> None: ...
-    def assertMultiLineEqual(self, first: str, second: str,
-                             msg: Any = ...) -> None: ...
-    def assertSequenceEqual(self, seq1: Sequence[Any], seq2: Sequence[Any],
-                            msg: Any = ...,
-                            seq_type: Optional[Type[Sequence[Any]]] = ...) -> None: ...
-    def assertListEqual(self, list1: List[Any], list2: List[Any],
-                        msg: Any = ...) -> None: ...
-    def assertTupleEqual(self, tuple1: Tuple[Any, ...], tuple2: Tuple[Any, ...],
-                         msg: Any = ...) -> None: ...
-    def assertSetEqual(self, set1: Union[Set[Any], FrozenSet[Any]],
-                       set2: Union[Set[Any], FrozenSet[Any]], msg: Any = ...) -> None: ...
-    def assertDictEqual(self, d1: Dict[Any, Any], d2: Dict[Any, Any],
-                        msg: Any = ...) -> None: ...
+    def assertNotAlmostEqual(
+        self,
+        first: datetime.datetime,
+        second: datetime.datetime,
+        places: Optional[int] = ...,
+        msg: Any = ...,
+        delta: Optional[datetime.timedelta] = ...,
+    ) -> None: ...
+    def assertRegex(self, text: AnyStr, expected_regex: Union[AnyStr, Pattern[AnyStr]], msg: Any = ...) -> None: ...
+    def assertNotRegex(self, text: AnyStr, unexpected_regex: Union[AnyStr, Pattern[AnyStr]], msg: Any = ...) -> None: ...
+    def assertCountEqual(self, first: Iterable[Any], second: Iterable[Any], msg: Any = ...) -> None: ...
+    def addTypeEqualityFunc(self, typeobj: Type[Any], function: Callable[..., None]) -> None: ...
+    def assertMultiLineEqual(self, first: str, second: str, msg: Any = ...) -> None: ...
+    def assertSequenceEqual(
+        self, seq1: Sequence[Any], seq2: Sequence[Any], msg: Any = ..., seq_type: Optional[Type[Sequence[Any]]] = ...
+    ) -> None: ...
+    def assertListEqual(self, list1: List[Any], list2: List[Any], msg: Any = ...) -> None: ...
+    def assertTupleEqual(self, tuple1: Tuple[Any, ...], tuple2: Tuple[Any, ...], msg: Any = ...) -> None: ...
+    def assertSetEqual(
+        self, set1: Union[Set[Any], FrozenSet[Any]], set2: Union[Set[Any], FrozenSet[Any]], msg: Any = ...
+    ) -> None: ...
+    def assertDictEqual(self, d1: Dict[Any, Any], d2: Dict[Any, Any], msg: Any = ...) -> None: ...
     def fail(self, msg: Any = ...) -> NoReturn: ...
     def countTestCases(self) -> int: ...
     def defaultTestResult(self) -> unittest.result.TestResult: ...
     def id(self) -> str: ...
     def shortDescription(self) -> Optional[str]: ...
-
     if sys.version_info >= (3, 8):
-        def addCleanup(self, __function: Callable[..., Any], *args: Any,
-                       **kwargs: Any) -> None: ...
+        def addCleanup(self, __function: Callable[..., Any], *args: Any, **kwargs: Any) -> None: ...
     else:
-        def addCleanup(self, function: Callable[..., Any], *args: Any,
-                       **kwargs: Any) -> None: ...
-
+        def addCleanup(self, function: Callable[..., Any], *args: Any, **kwargs: Any) -> None: ...
     def doCleanups(self) -> None: ...
     if sys.version_info >= (3, 8):
         @classmethod
@@ -182,65 +199,65 @@ class TestCase:
     def _formatMessage(self, msg: Optional[str], standardMsg: str) -> str: ...  # undocumented
     def _getAssertEqualityFunc(self, first: Any, second: Any) -> Callable[..., None]: ...  # undocumented
     # below is deprecated
-    def failUnlessEqual(self, first: Any, second: Any,
-                        msg: Any = ...) -> None: ...
+    def failUnlessEqual(self, first: Any, second: Any, msg: Any = ...) -> None: ...
     def assertEquals(self, first: Any, second: Any, msg: Any = ...) -> None: ...
     def failIfEqual(self, first: Any, second: Any, msg: Any = ...) -> None: ...
-    def assertNotEquals(self, first: Any, second: Any,
-                        msg: Any = ...) -> None: ...
+    def assertNotEquals(self, first: Any, second: Any, msg: Any = ...) -> None: ...
     def failUnless(self, expr: bool, msg: Any = ...) -> None: ...
     def assert_(self, expr: bool, msg: Any = ...) -> None: ...
     def failIf(self, expr: bool, msg: Any = ...) -> None: ...
     @overload
-    def failUnlessRaises(self,  # type: ignore
-                         exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]],
-                         callable: Callable[..., Any] = ...,
-                         *args: Any, **kwargs: Any) -> None: ...
+    def failUnlessRaises(  # type: ignore
+        self,
+        exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]],
+        callable: Callable[..., Any] = ...,
+        *args: Any,
+        **kwargs: Any,
+    ) -> None: ...
     @overload
-    def failUnlessRaises(self,
-                         exception: Union[Type[_E], Tuple[Type[_E], ...]],
-                         msg: Any = ...) -> _AssertRaisesContext[_E]: ...
-    def failUnlessAlmostEqual(self, first: float, second: float,
-                              places: int = ..., msg: Any = ...) -> None: ...
-    def assertAlmostEquals(self, first: float, second: float, places: int = ...,
-                           msg: Any = ..., delta: float = ...) -> None: ...
-    def failIfAlmostEqual(self, first: float, second: float, places: int = ...,
-                          msg: Any = ...) -> None: ...
-    def assertNotAlmostEquals(self, first: float, second: float,
-                              places: int = ..., msg: Any = ...,
-                              delta: float = ...) -> None: ...
-    def assertRegexpMatches(self, text: AnyStr, regex: Union[AnyStr, Pattern[AnyStr]],
-                            msg: Any = ...) -> None: ...
-    def assertNotRegexpMatches(self, text: AnyStr, regex: Union[AnyStr, Pattern[AnyStr]],
-                               msg: Any = ...) -> None: ...
+    def failUnlessRaises(self, exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any = ...) -> _AssertRaisesContext[_E]: ...
+    def failUnlessAlmostEqual(self, first: float, second: float, places: int = ..., msg: Any = ...) -> None: ...
+    def assertAlmostEquals(self, first: float, second: float, places: int = ..., msg: Any = ..., delta: float = ...) -> None: ...
+    def failIfAlmostEqual(self, first: float, second: float, places: int = ..., msg: Any = ...) -> None: ...
+    def assertNotAlmostEquals(
+        self, first: float, second: float, places: int = ..., msg: Any = ..., delta: float = ...
+    ) -> None: ...
+    def assertRegexpMatches(self, text: AnyStr, regex: Union[AnyStr, Pattern[AnyStr]], msg: Any = ...) -> None: ...
+    def assertNotRegexpMatches(self, text: AnyStr, regex: Union[AnyStr, Pattern[AnyStr]], msg: Any = ...) -> None: ...
     @overload
-    def assertRaisesRegexp(self,  # type: ignore
-                           exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]],
-                           expected_regex: Union[str, bytes, Pattern[str], Pattern[bytes]],
-                           callable: Callable[..., Any],
-                           *args: Any, **kwargs: Any) -> None: ...
+    def assertRaisesRegexp(  # type: ignore
+        self,
+        exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]],
+        expected_regex: Union[str, bytes, Pattern[str], Pattern[bytes]],
+        callable: Callable[..., Any],
+        *args: Any,
+        **kwargs: Any,
+    ) -> None: ...
     @overload
-    def assertRaisesRegexp(self,
-                           exception: Union[Type[_E], Tuple[Type[_E], ...]],
-                           expected_regex: Union[str, bytes, Pattern[str], Pattern[bytes]],
-                           msg: Any = ...) -> _AssertRaisesContext[_E]: ...
-    def assertDictContainsSubset(self,
-                                 subset: Mapping[Any, Any],
-                                 dictionary: Mapping[Any, Any],
-                                 msg: object = ...) -> None: ...
+    def assertRaisesRegexp(
+        self,
+        exception: Union[Type[_E], Tuple[Type[_E], ...]],
+        expected_regex: Union[str, bytes, Pattern[str], Pattern[bytes]],
+        msg: Any = ...,
+    ) -> _AssertRaisesContext[_E]: ...
+    def assertDictContainsSubset(self, subset: Mapping[Any, Any], dictionary: Mapping[Any, Any], msg: object = ...) -> None: ...
 
 class FunctionTestCase(TestCase):
-    def __init__(self, testFunc: Callable[[], None],
-                 setUp: Optional[Callable[[], None]] = ...,
-                 tearDown: Optional[Callable[[], None]] = ...,
-                 description: Optional[str] = ...) -> None: ...
+    def __init__(
+        self,
+        testFunc: Callable[[], None],
+        setUp: Optional[Callable[[], None]] = ...,
+        tearDown: Optional[Callable[[], None]] = ...,
+        description: Optional[str] = ...,
+    ) -> None: ...
     def runTest(self) -> None: ...
 
 class _AssertRaisesContext(Generic[_E]):
     exception: _E
     def __enter__(self) -> _AssertRaisesContext[_E]: ...
-    def __exit__(self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException],
-                 exc_tb: Optional[TracebackType]) -> bool: ...
+    def __exit__(
+        self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType]
+    ) -> bool: ...
 
 class _AssertWarnsContext:
     warning: warnings.WarningMessage
@@ -248,15 +265,16 @@ class _AssertWarnsContext:
     lineno: int
     warnings: List[warnings.WarningMessage]
     def __enter__(self) -> _AssertWarnsContext: ...
-    def __exit__(self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException],
-                 exc_tb: Optional[TracebackType]) -> None: ...
+    def __exit__(
+        self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType]
+    ) -> None: ...
 
 class _AssertLogsContext:
     LOGGING_FORMAT: str
     records: List[logging.LogRecord]
     output: List[str]
-    def __init__(self, test_case: unittest.case.TestCase,
-                 logger_name: str, level: int) -> None: ...
+    def __init__(self, test_case: unittest.case.TestCase, logger_name: str, level: int) -> None: ...
     def __enter__(self) -> _AssertLogsContext: ...
-    def __exit__(self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException],
-                 exc_tb: Optional[TracebackType]) -> Optional[bool]: ...
+    def __exit__(
+        self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType]
+    ) -> Optional[bool]: ...

stdlib/3/unittest/loader.pyi

@@ -1,11 +1,10 @@
 import sys
 import unittest.case
-import unittest.suite
 import unittest.result
+import unittest.suite
 from types import ModuleType
 from typing import Any, Callable, List, Optional, Sequence, Type
 
-
 _SortComparisonMethod = Callable[[str, str], int]
 _SuiteClass = Callable[[List[unittest.case.TestCase]], unittest.suite.TestSuite]
 
@@ -18,32 +17,34 @@ class TestLoader:
         testNamePatterns: Optional[List[str]]
 
     suiteClass: _SuiteClass
-    def loadTestsFromTestCase(self,
-                              testCaseClass: Type[unittest.case.TestCase]) -> unittest.suite.TestSuite: ...
+    def loadTestsFromTestCase(self, testCaseClass: Type[unittest.case.TestCase]) -> unittest.suite.TestSuite: ...
     def loadTestsFromModule(self, module: ModuleType, *args: Any, pattern: Any = ...) -> unittest.suite.TestSuite: ...
-    def loadTestsFromName(self, name: str,
-                          module: Optional[ModuleType] = ...) -> unittest.suite.TestSuite: ...
-    def loadTestsFromNames(self, names: Sequence[str],
-                           module: Optional[ModuleType] = ...) -> unittest.suite.TestSuite: ...
-    def getTestCaseNames(self,
-                         testCaseClass: Type[unittest.case.TestCase]) -> Sequence[str]: ...
-    def discover(self, start_dir: str, pattern: str = ...,
-                 top_level_dir: Optional[str] = ...) -> unittest.suite.TestSuite: ...
+    def loadTestsFromName(self, name: str, module: Optional[ModuleType] = ...) -> unittest.suite.TestSuite: ...
+    def loadTestsFromNames(self, names: Sequence[str], module: Optional[ModuleType] = ...) -> unittest.suite.TestSuite: ...
+    def getTestCaseNames(self, testCaseClass: Type[unittest.case.TestCase]) -> Sequence[str]: ...
+    def discover(self, start_dir: str, pattern: str = ..., top_level_dir: Optional[str] = ...) -> unittest.suite.TestSuite: ...
 
 defaultTestLoader: TestLoader
 
-
 if sys.version_info >= (3, 7):
-    def getTestCaseNames(testCaseClass: Type[unittest.case.TestCase], prefix: str,
-                         sortUsing: _SortComparisonMethod = ...,
-                         testNamePatterns: Optional[List[str]] = ...) -> Sequence[str]: ...
+    def getTestCaseNames(
+        testCaseClass: Type[unittest.case.TestCase],
+        prefix: str,
+        sortUsing: _SortComparisonMethod = ...,
+        testNamePatterns: Optional[List[str]] = ...,
+    ) -> Sequence[str]: ...
+
 else:
-    def getTestCaseNames(testCaseClass: Type[unittest.case.TestCase], prefix: str,
-                         sortUsing: _SortComparisonMethod = ...) -> Sequence[str]: ...
+    def getTestCaseNames(
+        testCaseClass: Type[unittest.case.TestCase], prefix: str, sortUsing: _SortComparisonMethod = ...
+    ) -> Sequence[str]: ...
 
-def makeSuite(testCaseClass: Type[unittest.case.TestCase], prefix: str = ...,
-              sortUsing: _SortComparisonMethod = ...,
-              suiteClass: _SuiteClass = ...) -> unittest.suite.TestSuite: ...
-
-def findTestCases(module, prefix: str = ..., sortUsing: _SortComparisonMethod = ...,
-                  suiteClass: _SuiteClass = ...) -> unittest.suite.TestSuite: ...
+def makeSuite(
+    testCaseClass: Type[unittest.case.TestCase],
+    prefix: str = ...,
+    sortUsing: _SortComparisonMethod = ...,
+    suiteClass: _SuiteClass = ...,
+) -> unittest.suite.TestSuite: ...
+def findTestCases(
+    module, prefix: str = ..., sortUsing: _SortComparisonMethod = ..., suiteClass: _SuiteClass = ...
+) -> unittest.suite.TestSuite: ...

stdlib/3/unittest/main.pyi

@@ -1,17 +1,13 @@
 import sys
-from typing import Any, Iterable, List, Optional, Protocol, Type, Union
-from types import ModuleType
-
 import unittest.case
 import unittest.loader
 import unittest.result
 import unittest.suite
+from types import ModuleType
+from typing import Any, Iterable, List, Optional, Protocol, Type, Union
 
 class _TestRunner(Protocol):
-    def run(
-        self, test: Union[unittest.suite.TestSuite, unittest.case.TestCase]
-    ) -> unittest.result.TestResult: ...
-
+    def run(self, test: Union[unittest.suite.TestSuite, unittest.case.TestCase]) -> unittest.result.TestResult: ...
 
 # not really documented
 class TestProgram:
@@ -26,26 +22,28 @@ class TestProgram:
 
     if sys.version_info >= (3, 7):
         testNamePatterns: Optional[List[str]]
-
-    def __init__(self, module: Union[None, str, ModuleType] = ...,
-                 defaultTest: Union[str, Iterable[str], None] = ...,
-                 argv: Optional[List[str]] = ...,
-                 testRunner: Union[Type[_TestRunner], _TestRunner, None] = ...,
-                 testLoader: unittest.loader.TestLoader = ...,
-                 exit: bool = ..., verbosity: int = ...,
-                 failfast: Optional[bool] = ..., catchbreak: Optional[bool] = ...,
-                 buffer: Optional[bool] = ...,
-                 warnings: Optional[str] = ..., *,
-                 tb_locals: bool = ...) -> None: ...
+    def __init__(
+        self,
+        module: Union[None, str, ModuleType] = ...,
+        defaultTest: Union[str, Iterable[str], None] = ...,
+        argv: Optional[List[str]] = ...,
+        testRunner: Union[Type[_TestRunner], _TestRunner, None] = ...,
+        testLoader: unittest.loader.TestLoader = ...,
+        exit: bool = ...,
+        verbosity: int = ...,
+        failfast: Optional[bool] = ...,
+        catchbreak: Optional[bool] = ...,
+        buffer: Optional[bool] = ...,
+        warnings: Optional[str] = ...,
+        *,
+        tb_locals: bool = ...,
+    ) -> None: ...
     def usageExit(self, msg: Any = ...) -> None: ...
     def parseArgs(self, argv: List[str]) -> None: ...
-
     if sys.version_info >= (3, 7):
-        def createTests(self, from_discovery: bool = ...,
-                        Loader: Optional[unittest.loader.TestLoader] = ...) -> None: ...
+        def createTests(self, from_discovery: bool = ..., Loader: Optional[unittest.loader.TestLoader] = ...) -> None: ...
     else:
         def createTests(self) -> None: ...
-
     def runTests(self) -> None: ...  # undocumented
 
 main = TestProgram

stdlib/3/unittest/mock.pyi

@@ -6,21 +6,21 @@ from typing import Any, List, Optional, Sequence, Text, Tuple, Type, TypeVar, Un
 _T = TypeVar("_T")
 
 __all__ = [
-    'Mock',
-    'MagicMock',
-    'patch',
-    'sentinel',
-    'DEFAULT',
-    'ANY',
-    'call',
-    'create_autospec',
-    'AsyncMock',
-    'FILTER_DIR',
-    'NonCallableMock',
-    'NonCallableMagicMock',
-    'mock_open',
-    'PropertyMock',
-    'seal',
+    "Mock",
+    "MagicMock",
+    "patch",
+    "sentinel",
+    "DEFAULT",
+    "ANY",
+    "call",
+    "create_autospec",
+    "AsyncMock",
+    "FILTER_DIR",
+    "NonCallableMock",
+    "NonCallableMagicMock",
+    "mock_open",
+    "PropertyMock",
+    "seal",
 ]
 __version__: str
 
@@ -40,11 +40,15 @@ sentinel: Any
 DEFAULT: Any
 
 class _Call(Tuple[Any, ...]):
-    def __new__(cls, value: Any = ..., name: Optional[Any] = ..., parent: Optional[Any] = ..., two: bool = ..., from_kall: bool = ...) -> Any: ...
+    def __new__(
+        cls, value: Any = ..., name: Optional[Any] = ..., parent: Optional[Any] = ..., two: bool = ..., from_kall: bool = ...
+    ) -> Any: ...
     name: Any
     parent: Any
     from_kall: Any
-    def __init__(self, value: Any = ..., name: Optional[Any] = ..., parent: Optional[Any] = ..., two: bool = ..., from_kall: bool = ...) -> None: ...
+    def __init__(
+        self, value: Any = ..., name: Optional[Any] = ..., parent: Optional[Any] = ..., two: bool = ..., from_kall: bool = ...
+    ) -> None: ...
     def __eq__(self, other: Any) -> bool: ...
     __ne__: Any
     def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
@@ -55,7 +59,6 @@ class _Call(Tuple[Any, ...]):
 
 call: Any
 
-
 class _CallList(List[_Call]):
     def __contains__(self, value: Any) -> bool: ...
 
@@ -68,53 +71,48 @@ class _MockIter:
 class Base:
     def __init__(self, *args: Any, **kwargs: Any) -> None: ...
 
-
 class NonCallableMock(Base, Any):  # type: ignore
     def __new__(cls, *args, **kw) -> NonCallableMock: ...
-    def __init__(self,
-                 spec: Union[List[str], object, Type[object], None] = ...,
-                 wraps: Optional[Any] = ...,
-                 name: Optional[str] = ...,
-                 spec_set: Union[List[str], object, Type[object], None] = ...,
-                 parent: Optional[NonCallableMock] = ...,
-                 _spec_state: Optional[Any] = ...,
-                 _new_name: str = ...,
-                 _new_parent: Optional[NonCallableMock] = ...,
-                 _spec_as_instance: bool = ...,
-                 _eat_self: Optional[bool] = ...,
-                 unsafe: bool = ..., **kwargs) -> None: ...
+    def __init__(
+        self,
+        spec: Union[List[str], object, Type[object], None] = ...,
+        wraps: Optional[Any] = ...,
+        name: Optional[str] = ...,
+        spec_set: Union[List[str], object, Type[object], None] = ...,
+        parent: Optional[NonCallableMock] = ...,
+        _spec_state: Optional[Any] = ...,
+        _new_name: str = ...,
+        _new_parent: Optional[NonCallableMock] = ...,
+        _spec_as_instance: bool = ...,
+        _eat_self: Optional[bool] = ...,
+        unsafe: bool = ...,
+        **kwargs,
+    ) -> None: ...
     def __getattr__(self, name: str) -> Any: ...
     if sys.version_info >= (3, 8):
         def _calls_repr(self, prefix: str = ...) -> str: ...
-
         def assert_called_with(self, *args: Any, **kwargs: Any) -> None: ...
         def assert_not_called(self) -> None: ...
         def assert_called_once_with(self, *args: Any, **kwargs: Any) -> None: ...
-
         def _format_mock_failure_message(self, args: Any, kwargs: Any, action: str = ...) -> str: ...
     elif sys.version_info >= (3, 5):
         def assert_called_with(_mock_self, *args: Any, **kwargs: Any) -> None: ...
         def assert_not_called(_mock_self) -> None: ...
         def assert_called_once_with(_mock_self, *args: Any, **kwargs: Any) -> None: ...
-
         def _format_mock_failure_message(self, args: Any, kwargs: Any) -> str: ...
-
     if sys.version_info >= (3, 8):
         def assert_called(self) -> None: ...
         def assert_called_once(self) -> None: ...
     elif sys.version_info >= (3, 6):
         def assert_called(_mock_self) -> None: ...
         def assert_called_once(_mock_self) -> None: ...
-
     if sys.version_info >= (3, 6):
         def reset_mock(self, visited: Any = ..., *, return_value: bool = ..., side_effect: bool = ...) -> None: ...
     elif sys.version_info >= (3, 5):
         def reset_mock(self, visited: Any = ...) -> None: ...
-
     if sys.version_info >= (3, 7):
         def _extract_mock_name(self) -> str: ...
         def _get_call_signature_from_name(self, name: str) -> Any: ...
-
     def assert_any_call(self, *args: Any, **kwargs: Any) -> None: ...
     def assert_has_calls(self, calls: Sequence[_Call], any_order: bool = ...) -> None: ...
     def mock_add_spec(self, spec: Any, spec_set: bool = ...) -> None: ...
@@ -132,10 +130,22 @@ class NonCallableMock(Base, Any):  # type: ignore
     def _call_matcher(self, _call: Tuple[_Call, ...]) -> _Call: ...
     def _get_child_mock(self, **kw: Any) -> NonCallableMock: ...
 
-
 class CallableMixin(Base):
     side_effect: Any
-    def __init__(self, spec: Optional[Any] = ..., side_effect: Optional[Any] = ..., return_value: Any = ..., wraps: Optional[Any] = ..., name: Optional[Any] = ..., spec_set: Optional[Any] = ..., parent: Optional[Any] = ..., _spec_state: Optional[Any] = ..., _new_name: Any = ..., _new_parent: Optional[Any] = ..., **kwargs: Any) -> None: ...
+    def __init__(
+        self,
+        spec: Optional[Any] = ...,
+        side_effect: Optional[Any] = ...,
+        return_value: Any = ...,
+        wraps: Optional[Any] = ...,
+        name: Optional[Any] = ...,
+        spec_set: Optional[Any] = ...,
+        parent: Optional[Any] = ...,
+        _spec_state: Optional[Any] = ...,
+        _new_name: Any = ...,
+        _new_parent: Optional[Any] = ...,
+        **kwargs: Any,
+    ) -> None: ...
     def __call__(_mock_self, *args: Any, **kwargs: Any) -> Any: ...
 
 class Mock(CallableMixin, NonCallableMock): ...
@@ -153,7 +163,18 @@ class _patch:
     autospec: Any
     kwargs: Any
     additional_patchers: Any
-    def __init__(self, getter: Any, attribute: Any, new: Any, spec: Any, create: Any, spec_set: Any, autospec: Any, new_callable: Any, kwargs: Any) -> None: ...
+    def __init__(
+        self,
+        getter: Any,
+        attribute: Any,
+        new: Any,
+        spec: Any,
+        create: Any,
+        spec_set: Any,
+        autospec: Any,
+        new_callable: Any,
+        kwargs: Any,
+    ) -> None: ...
     def copy(self) -> Any: ...
     def __call__(self, func: Any) -> Any: ...
     def decorate_class(self, klass: Any) -> Any: ...
@@ -182,9 +203,39 @@ class _patch_dict:
 class _patcher:
     TEST_PREFIX: str
     dict: Type[_patch_dict]
-    def __call__(self, target: Any, new: Optional[Any] = ..., spec: Optional[Any] = ..., create: bool = ..., spec_set: Optional[Any] = ..., autospec: Optional[Any] = ..., new_callable: Optional[Any] = ..., **kwargs: Any) -> _patch: ...
-    def object(self, target: Any, attribute: Text, new: Optional[Any] = ..., spec: Optional[Any] = ..., create: bool = ..., spec_set: Optional[Any] = ..., autospec: Optional[Any] = ..., new_callable: Optional[Any] = ..., **kwargs: Any) -> _patch: ...
-    def multiple(self, target: Any, spec: Optional[Any] = ..., create: bool = ..., spec_set: Optional[Any] = ..., autospec: Optional[Any] = ..., new_callable: Optional[Any] = ..., **kwargs: Any) -> _patch: ...
+    def __call__(
+        self,
+        target: Any,
+        new: Optional[Any] = ...,
+        spec: Optional[Any] = ...,
+        create: bool = ...,
+        spec_set: Optional[Any] = ...,
+        autospec: Optional[Any] = ...,
+        new_callable: Optional[Any] = ...,
+        **kwargs: Any,
+    ) -> _patch: ...
+    def object(
+        self,
+        target: Any,
+        attribute: Text,
+        new: Optional[Any] = ...,
+        spec: Optional[Any] = ...,
+        create: bool = ...,
+        spec_set: Optional[Any] = ...,
+        autospec: Optional[Any] = ...,
+        new_callable: Optional[Any] = ...,
+        **kwargs: Any,
+    ) -> _patch: ...
+    def multiple(
+        self,
+        target: Any,
+        spec: Optional[Any] = ...,
+        create: bool = ...,
+        spec_set: Optional[Any] = ...,
+        autospec: Optional[Any] = ...,
+        new_callable: Optional[Any] = ...,
+        **kwargs: Any,
+    ) -> _patch: ...
     def stopall(self) -> None: ...
 
 patch: _patcher
@@ -215,7 +266,9 @@ class _ANY:
 
 ANY: Any
 
-def create_autospec(spec: Any, spec_set: Any = ..., instance: Any = ..., _parent: Optional[Any] = ..., _name: Optional[Any] = ..., **kwargs: Any) -> Any: ...
+def create_autospec(
+    spec: Any, spec_set: Any = ..., instance: Any = ..., _parent: Optional[Any] = ..., _name: Optional[Any] = ..., **kwargs: Any
+) -> Any: ...
 
 class _SpecState:
     spec: Any
@@ -224,7 +277,15 @@ class _SpecState:
     parent: Any
     instance: Any
     name: Any
-    def __init__(self, spec: Any, spec_set: Any = ..., parent: Optional[Any] = ..., name: Optional[Any] = ..., ids: Optional[Any] = ..., instance: Any = ...) -> None: ...
+    def __init__(
+        self,
+        spec: Any,
+        spec_set: Any = ...,
+        parent: Optional[Any] = ...,
+        name: Optional[Any] = ...,
+        ids: Optional[Any] = ...,
+        instance: Any = ...,
+    ) -> None: ...
 
 def mock_open(mock: Optional[Any] = ..., read_data: Any = ...) -> Any: ...
 

stdlib/3/unittest/result.pyi

@@ -1,11 +1,9 @@
-from typing import Any, Callable, List, Optional, TextIO, Tuple, Type, TypeVar, Union
-from types import TracebackType
 import unittest.case
-
+from types import TracebackType
+from typing import Any, Callable, List, Optional, TextIO, Tuple, Type, TypeVar, Union
 
 _SysExcInfoType = Union[
-    Tuple[Type[BaseException], BaseException, TracebackType],
-    Tuple[None, None, None],
+    Tuple[Type[BaseException], BaseException, TracebackType], Tuple[None, None, None],
 ]
 
 _F = TypeVar("_F", bound=Callable[..., Any])
@@ -13,7 +11,6 @@ _F = TypeVar("_F", bound=Callable[..., Any])
 # undocumented
 def failfast(method: _F) -> _F: ...
 
-
 class TestResult:
     errors: List[Tuple[unittest.case.TestCase, str]]
     failures: List[Tuple[unittest.case.TestCase, str]]
@@ -25,9 +22,9 @@ class TestResult:
     buffer: bool
     failfast: bool
     tb_locals: bool
-    def __init__(self, stream: Optional[TextIO] = ...,
-                 descriptions: Optional[bool] = ...,
-                 verbosity: Optional[int] = ...) -> None: ...
+    def __init__(
+        self, stream: Optional[TextIO] = ..., descriptions: Optional[bool] = ..., verbosity: Optional[int] = ...
+    ) -> None: ...
     def printErrors(self) -> None: ...
     def wasSuccessful(self) -> bool: ...
     def stop(self) -> None: ...
@@ -39,8 +36,8 @@ class TestResult:
     def addFailure(self, test: unittest.case.TestCase, err: _SysExcInfoType) -> None: ...
     def addSuccess(self, test: unittest.case.TestCase) -> None: ...
     def addSkip(self, test: unittest.case.TestCase, reason: str) -> None: ...
-    def addExpectedFailure(self, test: unittest.case.TestCase,
-                           err: _SysExcInfoType) -> None: ...
+    def addExpectedFailure(self, test: unittest.case.TestCase, err: _SysExcInfoType) -> None: ...
     def addUnexpectedSuccess(self, test: unittest.case.TestCase) -> None: ...
-    def addSubTest(self, test: unittest.case.TestCase, subtest: unittest.case.TestCase,
-                   err: Optional[_SysExcInfoType]) -> None: ...
+    def addSubTest(
+        self, test: unittest.case.TestCase, subtest: unittest.case.TestCase, err: Optional[_SysExcInfoType]
+    ) -> None: ...

stdlib/3/unittest/runner.pyi

@@ -1,12 +1,10 @@
-from typing import Callable, Optional, TextIO, Tuple, Type, Union
 import unittest.case
 import unittest.result
 import unittest.suite
-
+from typing import Callable, Optional, TextIO, Tuple, Type, Union
 
 _ResultClassType = Callable[[TextIO, bool, int], unittest.result.TestResult]
 
-
 class TextTestResult(unittest.result.TestResult):
     descriptions: bool  # undocumented
     dots: bool  # undocumented
@@ -14,13 +12,11 @@ class TextTestResult(unittest.result.TestResult):
     separator2: str
     showall: bool  # undocumented
     stream: TextIO  # undocumented
-    def __init__(self, stream: TextIO, descriptions: bool,
-                 verbosity: int) -> None: ...
+    def __init__(self, stream: TextIO, descriptions: bool, verbosity: int) -> None: ...
     def getDescription(self, test: unittest.case.TestCase) -> str: ...
     def printErrors(self) -> None: ...
     def printErrorList(self, flavour: str, errors: Tuple[unittest.case.TestCase, str]) -> None: ...
 
-
 class TextTestRunner(object):
     resultclass: _ResultClassType
     def __init__(

stdlib/3/unittest/signals.pyi

@@ -1,9 +1,7 @@
-from typing import Any, Callable, overload, TypeVar
 import unittest.result
+from typing import Any, Callable, TypeVar, overload
 
-
-_F = TypeVar('_F', bound=Callable[..., Any])
-
+_F = TypeVar("_F", bound=Callable[..., Any])
 
 def installHandler() -> None: ...
 def registerResult(result: unittest.result.TestResult) -> None: ...

stdlib/3/unittest/suite.pyi

@@ -1,11 +1,9 @@
-from typing import Iterable, Iterator, List, Union
 import unittest.case
 import unittest.result
-
+from typing import Iterable, Iterator, List, Union
 
 _TestType = Union[unittest.case.TestCase, TestSuite]
 
-
 class BaseTestSuite(Iterable[_TestType]):
     _tests: List[unittest.case.TestCase]
     _removed_tests: int
@@ -18,7 +16,5 @@ class BaseTestSuite(Iterable[_TestType]):
     def countTestCases(self) -> int: ...
     def __iter__(self) -> Iterator[_TestType]: ...
 
-
 class TestSuite(BaseTestSuite):
-    def run(self, result: unittest.result.TestResult,
-            debug: bool = ...) -> unittest.result.TestResult: ...
+    def run(self, result: unittest.result.TestResult, debug: bool = ...) -> unittest.result.TestResult: ...

stdlib/3/unittest/util.pyi

@@ -1,7 +1,7 @@
 # undocumented
 from typing import Any, List, Sequence, Tuple, TypeVar
 
-_T = TypeVar('_T')
+_T = TypeVar("_T")
 _Mismatch = Tuple[_T, _T, int]
 
 _MAX_LENGTH: int