mirror of
https://github.com/davidhalter/typeshed.git
synced 2026-01-24 03:51:52 +08:00
Re-organize directory structure (#4971)
See discussion in #2491 Co-authored-by: Ivan Levkivskyi <ilevkivskyi@dropbox.com>
This commit is contained in:
Ivan Levkivskyi
11
stdlib/unittest/__init__.pyi
Normal file
11
stdlib/unittest/__init__.pyi
Normal file
@@ -0,0 +1,11 @@
|
||||
from typing import Optional
|
||||
from unittest.async_case import *
|
||||
from unittest.case import *
|
||||
from unittest.loader import *
|
||||
from unittest.main import *
|
||||
from unittest.result import TestResult as TestResult
|
||||
from unittest.runner import *
|
||||
from unittest.signals import *
|
||||
from unittest.suite import *
|
||||
|
||||
def load_tests(loader: TestLoader, tests: TestSuite, pattern: Optional[str]) -> TestSuite: ...
|
||||
10
stdlib/unittest/async_case.pyi
Normal file
10
stdlib/unittest/async_case.pyi
Normal file
@@ -0,0 +1,10 @@
|
||||
import sys
|
||||
from typing import Any, Awaitable, Callable
|
||||
|
||||
from .case import TestCase
|
||||
|
||||
if sys.version_info >= (3, 8):
|
||||
class IsolatedAsyncioTestCase(TestCase):
|
||||
async def asyncSetUp(self) -> None: ...
|
||||
async def asyncTearDown(self) -> None: ...
|
||||
def addAsyncCleanup(self, __func: Callable[..., Awaitable[Any]], *args: Any, **kwargs: Any) -> None: ...
|
||||
285
stdlib/unittest/case.pyi
Normal file
285
stdlib/unittest/case.pyi
Normal file
@@ -0,0 +1,285 @@
|
||||
import datetime
|
||||
import logging
|
||||
import sys
|
||||
import unittest.result
|
||||
from types import TracebackType
|
||||
from typing import (
|
||||
Any,
|
||||
AnyStr,
|
||||
Callable,
|
||||
Container,
|
||||
ContextManager,
|
||||
Dict,
|
||||
FrozenSet,
|
||||
Generic,
|
||||
Iterable,
|
||||
List,
|
||||
Mapping,
|
||||
NoReturn,
|
||||
Optional,
|
||||
Pattern,
|
||||
Sequence,
|
||||
Set,
|
||||
Tuple,
|
||||
Type,
|
||||
TypeVar,
|
||||
Union,
|
||||
overload,
|
||||
)
|
||||
from warnings import WarningMessage
|
||||
|
||||
if sys.version_info >= (3, 9):
|
||||
from types import GenericAlias
|
||||
|
||||
_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: ...
|
||||
def doModuleCleanups() -> None: ...
|
||||
|
||||
def expectedFailure(test_item: _FT) -> _FT: ...
|
||||
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
|
||||
maxDiff: Optional[int]
|
||||
# undocumented
|
||||
_testMethodName: str
|
||||
# undocumented
|
||||
_testMethodDoc: str
|
||||
def __init__(self, methodName: str = ...) -> None: ...
|
||||
def setUp(self) -> None: ...
|
||||
def tearDown(self) -> None: ...
|
||||
@classmethod
|
||||
def setUpClass(cls) -> None: ...
|
||||
@classmethod
|
||||
def tearDownClass(cls) -> None: ...
|
||||
def run(self, result: Optional[unittest.result.TestResult] = ...) -> Optional[unittest.result.TestResult]: ...
|
||||
def __call__(self, result: Optional[unittest.result.TestResult] = ...) -> Optional[unittest.result.TestResult]: ...
|
||||
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: 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 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 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( # 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]: ...
|
||||
@overload
|
||||
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]: ...
|
||||
@overload
|
||||
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: ...
|
||||
@overload
|
||||
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 assertLogs(
|
||||
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: ...
|
||||
@overload
|
||||
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: ...
|
||||
@overload
|
||||
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: ...
|
||||
@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 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: ...
|
||||
else:
|
||||
def addCleanup(self, function: Callable[..., Any], *args: Any, **kwargs: Any) -> None: ...
|
||||
def doCleanups(self) -> None: ...
|
||||
if sys.version_info >= (3, 8):
|
||||
@classmethod
|
||||
def addClassCleanup(cls, __function: Callable[..., Any], *args: Any, **kwargs: Any) -> None: ...
|
||||
@classmethod
|
||||
def doClassCleanups(cls) -> None: ...
|
||||
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 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 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( # 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: ...
|
||||
@overload
|
||||
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: ...
|
||||
|
||||
class FunctionTestCase(TestCase):
|
||||
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: ...
|
||||
if sys.version_info >= (3, 9):
|
||||
def __class_getitem__(cls, item: Any) -> GenericAlias: ...
|
||||
|
||||
class _AssertWarnsContext:
|
||||
warning: WarningMessage
|
||||
filename: str
|
||||
lineno: int
|
||||
warnings: List[WarningMessage]
|
||||
def __enter__(self) -> _AssertWarnsContext: ...
|
||||
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: 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]: ...
|
||||
50
stdlib/unittest/loader.pyi
Normal file
50
stdlib/unittest/loader.pyi
Normal file
@@ -0,0 +1,50 @@
|
||||
import sys
|
||||
import unittest.case
|
||||
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]
|
||||
|
||||
class TestLoader:
|
||||
errors: List[Type[BaseException]]
|
||||
testMethodPrefix: str
|
||||
sortTestMethodsUsing: _SortComparisonMethod
|
||||
|
||||
if sys.version_info >= (3, 7):
|
||||
testNamePatterns: Optional[List[str]]
|
||||
|
||||
suiteClass: _SuiteClass
|
||||
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: ...
|
||||
|
||||
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]: ...
|
||||
|
||||
else:
|
||||
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: ModuleType, prefix: str = ..., sortUsing: _SortComparisonMethod = ..., suiteClass: _SuiteClass = ...
|
||||
) -> unittest.suite.TestSuite: ...
|
||||
49
stdlib/unittest/main.pyi
Normal file
49
stdlib/unittest/main.pyi
Normal file
@@ -0,0 +1,49 @@
|
||||
import sys
|
||||
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: ...
|
||||
|
||||
# not really documented
|
||||
class TestProgram:
|
||||
result: unittest.result.TestResult
|
||||
module: Union[None, str, ModuleType]
|
||||
verbosity: int
|
||||
failfast: Optional[bool]
|
||||
catchbreak: Optional[bool]
|
||||
buffer: Optional[bool]
|
||||
progName: Optional[str]
|
||||
warnings: Optional[str]
|
||||
|
||||
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 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: ...
|
||||
else:
|
||||
def createTests(self) -> None: ...
|
||||
def runTests(self) -> None: ... # undocumented
|
||||
|
||||
main = TestProgram
|
||||
395
stdlib/unittest/mock.pyi
Normal file
395
stdlib/unittest/mock.pyi
Normal file
@@ -0,0 +1,395 @@
|
||||
import sys
|
||||
from typing import Any, Callable, Generic, List, Mapping, Optional, Sequence, Tuple, Type, TypeVar, Union, overload
|
||||
|
||||
_F = TypeVar("_F", bound=Callable[..., Any])
|
||||
_T = TypeVar("_T")
|
||||
_TT = TypeVar("_TT", bound=Type[Any])
|
||||
_R = TypeVar("_R")
|
||||
|
||||
__all__ = [
|
||||
"Mock",
|
||||
"MagicMock",
|
||||
"patch",
|
||||
"sentinel",
|
||||
"DEFAULT",
|
||||
"ANY",
|
||||
"call",
|
||||
"create_autospec",
|
||||
"AsyncMock",
|
||||
"FILTER_DIR",
|
||||
"NonCallableMock",
|
||||
"NonCallableMagicMock",
|
||||
"mock_open",
|
||||
"PropertyMock",
|
||||
"seal",
|
||||
]
|
||||
__version__: str
|
||||
|
||||
FILTER_DIR: Any
|
||||
|
||||
class _slotted: ...
|
||||
|
||||
class _SentinelObject:
|
||||
name: Any
|
||||
def __init__(self, name: Any) -> None: ...
|
||||
|
||||
class _Sentinel:
|
||||
def __init__(self) -> None: ...
|
||||
def __getattr__(self, name: str) -> Any: ...
|
||||
|
||||
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: ...
|
||||
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 __eq__(self, other: Any) -> bool: ...
|
||||
__ne__: Any
|
||||
def __call__(self, *args: Any, **kwargs: Any) -> _Call: ...
|
||||
def __getattr__(self, attr: Any) -> Any: ...
|
||||
def count(self, *args: Any, **kwargs: Any) -> Any: ...
|
||||
def index(self, *args: Any, **kwargs: Any) -> Any: ...
|
||||
def call_list(self) -> Any: ...
|
||||
|
||||
call: _Call
|
||||
|
||||
class _CallList(List[_Call]):
|
||||
def __contains__(self, value: Any) -> bool: ...
|
||||
|
||||
class _MockIter:
|
||||
obj: Any
|
||||
def __init__(self, obj: Any) -> None: ...
|
||||
def __iter__(self) -> Any: ...
|
||||
def __next__(self) -> Any: ...
|
||||
|
||||
class Base:
|
||||
def __init__(self, *args: Any, **kwargs: Any) -> None: ...
|
||||
|
||||
class NonCallableMock(Base, Any): # type: ignore
|
||||
def __new__(__cls, *args: Any, **kw: Any) -> 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: Any,
|
||||
) -> 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: ...
|
||||
def reset_mock(self, visited: Any = ..., *, return_value: bool = ..., side_effect: bool = ...) -> 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: ...
|
||||
def _mock_add_spec(self, spec: Any, spec_set: bool, _spec_as_instance: bool = ..., _eat_self: bool = ...) -> None: ...
|
||||
def attach_mock(self, mock: NonCallableMock, attribute: str) -> None: ...
|
||||
def configure_mock(self, **kwargs: Any) -> None: ...
|
||||
return_value: Any
|
||||
side_effect: Any
|
||||
called: bool
|
||||
call_count: int
|
||||
call_args: Any
|
||||
call_args_list: _CallList
|
||||
mock_calls: _CallList
|
||||
def _format_mock_call_signature(self, args: Any, kwargs: Any) -> str: ...
|
||||
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 __call__(_mock_self, *args: Any, **kwargs: Any) -> Any: ...
|
||||
|
||||
class Mock(CallableMixin, NonCallableMock): ...
|
||||
|
||||
class _patch(Generic[_T]):
|
||||
attribute_name: Any
|
||||
getter: Callable[[], Any]
|
||||
attribute: str
|
||||
new: _T
|
||||
new_callable: Any
|
||||
spec: Any
|
||||
create: bool
|
||||
has_local: Any
|
||||
spec_set: Any
|
||||
autospec: Any
|
||||
kwargs: Mapping[str, Any]
|
||||
additional_patchers: Any
|
||||
# If new==DEFAULT, self is _patch[Any]. Ideally we'd be able to add an overload for it so that self is _patch[MagicMock],
|
||||
# but that's impossible with the current type system.
|
||||
def __init__(
|
||||
self: _patch[_T],
|
||||
getter: Callable[[], Any],
|
||||
attribute: str,
|
||||
new: _T,
|
||||
spec: Optional[Any],
|
||||
create: bool,
|
||||
spec_set: Optional[Any],
|
||||
autospec: Optional[Any],
|
||||
new_callable: Optional[Any],
|
||||
kwargs: Mapping[str, Any],
|
||||
) -> None: ...
|
||||
def copy(self) -> _patch[_T]: ...
|
||||
def __call__(self, func: Callable[..., _R]) -> Callable[..., _R]: ...
|
||||
def decorate_class(self, klass: _TT) -> _TT: ...
|
||||
def decorate_callable(self, func: _F) -> _F: ...
|
||||
def get_original(self) -> Tuple[Any, bool]: ...
|
||||
target: Any
|
||||
temp_original: Any
|
||||
is_local: bool
|
||||
def __enter__(self) -> _T: ...
|
||||
def __exit__(self, *exc_info: Any) -> None: ...
|
||||
def start(self) -> _T: ...
|
||||
def stop(self) -> None: ...
|
||||
|
||||
class _patch_dict:
|
||||
in_dict: Any
|
||||
values: Any
|
||||
clear: Any
|
||||
def __init__(self, in_dict: Any, values: Any = ..., clear: Any = ..., **kwargs: Any) -> None: ...
|
||||
def __call__(self, f: Any) -> Any: ...
|
||||
def decorate_class(self, klass: Any) -> Any: ...
|
||||
def __enter__(self) -> Any: ...
|
||||
def __exit__(self, *args: Any) -> Any: ...
|
||||
start: Any
|
||||
stop: Any
|
||||
|
||||
class _patcher:
|
||||
TEST_PREFIX: str
|
||||
dict: Type[_patch_dict]
|
||||
if sys.version_info >= (3, 8):
|
||||
@overload
|
||||
def __call__( # type: ignore
|
||||
self,
|
||||
target: Any,
|
||||
*,
|
||||
spec: Optional[Any] = ...,
|
||||
create: bool = ...,
|
||||
spec_set: Optional[Any] = ...,
|
||||
autospec: Optional[Any] = ...,
|
||||
new_callable: Optional[Any] = ...,
|
||||
**kwargs: Any,
|
||||
) -> _patch[Union[MagicMock, AsyncMock]]: ...
|
||||
# This overload also covers the case, where new==DEFAULT. In this case, the return type is _patch[Any].
|
||||
# Ideally we'd be able to add an overload for it so that the return type is _patch[MagicMock],
|
||||
# but that's impossible with the current type system.
|
||||
@overload
|
||||
def __call__(
|
||||
self,
|
||||
target: Any,
|
||||
new: _T,
|
||||
spec: Optional[Any] = ...,
|
||||
create: bool = ...,
|
||||
spec_set: Optional[Any] = ...,
|
||||
autospec: Optional[Any] = ...,
|
||||
new_callable: Optional[Any] = ...,
|
||||
**kwargs: Any,
|
||||
) -> _patch[_T]: ...
|
||||
else:
|
||||
@overload
|
||||
def __call__( # type: ignore
|
||||
self,
|
||||
target: Any,
|
||||
*,
|
||||
spec: Optional[Any] = ...,
|
||||
create: bool = ...,
|
||||
spec_set: Optional[Any] = ...,
|
||||
autospec: Optional[Any] = ...,
|
||||
new_callable: Optional[Any] = ...,
|
||||
**kwargs: Any,
|
||||
) -> _patch[MagicMock]: ...
|
||||
@overload
|
||||
def __call__(
|
||||
self,
|
||||
target: Any,
|
||||
new: _T,
|
||||
spec: Optional[Any] = ...,
|
||||
create: bool = ...,
|
||||
spec_set: Optional[Any] = ...,
|
||||
autospec: Optional[Any] = ...,
|
||||
new_callable: Optional[Any] = ...,
|
||||
**kwargs: Any,
|
||||
) -> _patch[_T]: ...
|
||||
if sys.version_info >= (3, 8):
|
||||
@overload
|
||||
def object( # type: ignore
|
||||
self,
|
||||
target: Any,
|
||||
attribute: str,
|
||||
*,
|
||||
spec: Optional[Any] = ...,
|
||||
create: bool = ...,
|
||||
spec_set: Optional[Any] = ...,
|
||||
autospec: Optional[Any] = ...,
|
||||
new_callable: Optional[Any] = ...,
|
||||
**kwargs: Any,
|
||||
) -> _patch[Union[MagicMock, AsyncMock]]: ...
|
||||
@overload
|
||||
def object(
|
||||
self,
|
||||
target: Any,
|
||||
attribute: str,
|
||||
new: _T = ...,
|
||||
spec: Optional[Any] = ...,
|
||||
create: bool = ...,
|
||||
spec_set: Optional[Any] = ...,
|
||||
autospec: Optional[Any] = ...,
|
||||
new_callable: Optional[Any] = ...,
|
||||
**kwargs: Any,
|
||||
) -> _patch[_T]: ...
|
||||
else:
|
||||
@overload
|
||||
def object( # type: ignore
|
||||
self,
|
||||
target: Any,
|
||||
attribute: str,
|
||||
*,
|
||||
spec: Optional[Any] = ...,
|
||||
create: bool = ...,
|
||||
spec_set: Optional[Any] = ...,
|
||||
autospec: Optional[Any] = ...,
|
||||
new_callable: Optional[Any] = ...,
|
||||
**kwargs: Any,
|
||||
) -> _patch[MagicMock]: ...
|
||||
@overload
|
||||
def object(
|
||||
self,
|
||||
target: Any,
|
||||
attribute: str,
|
||||
new: _T = ...,
|
||||
spec: Optional[Any] = ...,
|
||||
create: bool = ...,
|
||||
spec_set: Optional[Any] = ...,
|
||||
autospec: Optional[Any] = ...,
|
||||
new_callable: Optional[Any] = ...,
|
||||
**kwargs: Any,
|
||||
) -> _patch[_T]: ...
|
||||
def multiple(
|
||||
self,
|
||||
target: Any,
|
||||
spec: Optional[Any] = ...,
|
||||
create: bool = ...,
|
||||
spec_set: Optional[Any] = ...,
|
||||
autospec: Optional[Any] = ...,
|
||||
new_callable: Optional[Any] = ...,
|
||||
**kwargs: _T,
|
||||
) -> _patch[_T]: ...
|
||||
def stopall(self) -> None: ...
|
||||
|
||||
patch: _patcher
|
||||
|
||||
class MagicMixin:
|
||||
def __init__(self, *args: Any, **kw: Any) -> None: ...
|
||||
|
||||
class NonCallableMagicMock(MagicMixin, NonCallableMock):
|
||||
def mock_add_spec(self, spec: Any, spec_set: bool = ...) -> None: ...
|
||||
|
||||
class MagicMock(MagicMixin, Mock):
|
||||
def mock_add_spec(self, spec: Any, spec_set: bool = ...) -> None: ...
|
||||
|
||||
if sys.version_info >= (3, 8):
|
||||
class AsyncMockMixin(Base):
|
||||
def __init__(self, *args: Any, **kwargs: Any) -> None: ...
|
||||
async def _execute_mock_call(self, *args: Any, **kwargs: Any) -> Any: ...
|
||||
def assert_awaited(self) -> None: ...
|
||||
def assert_awaited_once(self) -> None: ...
|
||||
def assert_awaited_with(self, *args: Any, **kwargs: Any) -> None: ...
|
||||
def assert_awaited_once_with(self, *args: Any, **kwargs: Any) -> None: ...
|
||||
def assert_any_await(self, *args: Any, **kwargs: Any) -> None: ...
|
||||
def assert_has_awaits(self, calls: _CallList, any_order: bool = ...) -> None: ...
|
||||
def assert_not_awaited(self) -> None: ...
|
||||
def reset_mock(self, *args: Any, **kwargs: Any) -> None: ...
|
||||
await_count: int
|
||||
await_args: Optional[_Call]
|
||||
await_args_list: _CallList
|
||||
class AsyncMagicMixin(MagicMixin):
|
||||
def __init__(self, *args: Any, **kw: Any) -> None: ...
|
||||
class AsyncMock(AsyncMockMixin, AsyncMagicMixin, Mock): ...
|
||||
|
||||
class MagicProxy:
|
||||
name: Any
|
||||
parent: Any
|
||||
def __init__(self, name: Any, parent: Any) -> None: ...
|
||||
def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
|
||||
def create_mock(self) -> Any: ...
|
||||
def __get__(self, obj: Any, _type: Optional[Any] = ...) -> Any: ...
|
||||
|
||||
class _ANY:
|
||||
def __eq__(self, other: Any) -> bool: ...
|
||||
def __ne__(self, other: Any) -> bool: ...
|
||||
|
||||
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
|
||||
ids: Any
|
||||
spec_set: Any
|
||||
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 mock_open(mock: Optional[Any] = ..., read_data: Any = ...) -> Any: ...
|
||||
|
||||
PropertyMock = Any
|
||||
|
||||
if sys.version_info >= (3, 7):
|
||||
def seal(mock: Any) -> None: ...
|
||||
41
stdlib/unittest/result.pyi
Normal file
41
stdlib/unittest/result.pyi
Normal file
@@ -0,0 +1,41 @@
|
||||
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]]
|
||||
|
||||
_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]]
|
||||
skipped: List[Tuple[unittest.case.TestCase, str]]
|
||||
expectedFailures: List[Tuple[unittest.case.TestCase, str]]
|
||||
unexpectedSuccesses: List[unittest.case.TestCase]
|
||||
shouldStop: bool
|
||||
testsRun: int
|
||||
buffer: bool
|
||||
failfast: bool
|
||||
tb_locals: bool
|
||||
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: ...
|
||||
def startTest(self, test: unittest.case.TestCase) -> None: ...
|
||||
def stopTest(self, test: unittest.case.TestCase) -> None: ...
|
||||
def startTestRun(self) -> None: ...
|
||||
def stopTestRun(self) -> None: ...
|
||||
def addError(self, test: unittest.case.TestCase, err: _SysExcInfoType) -> None: ...
|
||||
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 addUnexpectedSuccess(self, test: unittest.case.TestCase) -> None: ...
|
||||
def addSubTest(
|
||||
self, test: unittest.case.TestCase, subtest: unittest.case.TestCase, err: Optional[_SysExcInfoType]
|
||||
) -> None: ...
|
||||
35
stdlib/unittest/runner.pyi
Normal file
35
stdlib/unittest/runner.pyi
Normal file
@@ -0,0 +1,35 @@
|
||||
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
|
||||
separator1: str
|
||||
separator2: str
|
||||
showall: bool # undocumented
|
||||
stream: TextIO # undocumented
|
||||
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__(
|
||||
self,
|
||||
stream: Optional[TextIO] = ...,
|
||||
descriptions: bool = ...,
|
||||
verbosity: int = ...,
|
||||
failfast: bool = ...,
|
||||
buffer: bool = ...,
|
||||
resultclass: Optional[_ResultClassType] = ...,
|
||||
warnings: Optional[Type[Warning]] = ...,
|
||||
*,
|
||||
tb_locals: bool = ...,
|
||||
) -> None: ...
|
||||
def _makeResult(self) -> unittest.result.TestResult: ...
|
||||
def run(self, test: Union[unittest.suite.TestSuite, unittest.case.TestCase]) -> unittest.result.TestResult: ...
|
||||
12
stdlib/unittest/signals.pyi
Normal file
12
stdlib/unittest/signals.pyi
Normal file
@@ -0,0 +1,12 @@
|
||||
import unittest.result
|
||||
from typing import Any, Callable, TypeVar, overload
|
||||
|
||||
_F = TypeVar("_F", bound=Callable[..., Any])
|
||||
|
||||
def installHandler() -> None: ...
|
||||
def registerResult(result: unittest.result.TestResult) -> None: ...
|
||||
def removeResult(result: unittest.result.TestResult) -> bool: ...
|
||||
@overload
|
||||
def removeHandler(method: None = ...) -> None: ...
|
||||
@overload
|
||||
def removeHandler(method: _F) -> _F: ...
|
||||
20
stdlib/unittest/suite.pyi
Normal file
20
stdlib/unittest/suite.pyi
Normal file
@@ -0,0 +1,20 @@
|
||||
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
|
||||
def __init__(self, tests: Iterable[_TestType] = ...) -> None: ...
|
||||
def __call__(self, result: unittest.result.TestResult) -> unittest.result.TestResult: ...
|
||||
def addTest(self, test: _TestType) -> None: ...
|
||||
def addTests(self, tests: Iterable[_TestType]) -> None: ...
|
||||
def run(self, result: unittest.result.TestResult) -> unittest.result.TestResult: ...
|
||||
def debug(self) -> None: ...
|
||||
def countTestCases(self) -> int: ...
|
||||
def __iter__(self) -> Iterator[_TestType]: ...
|
||||
|
||||
class TestSuite(BaseTestSuite):
|
||||
def run(self, result: unittest.result.TestResult, debug: bool = ...) -> unittest.result.TestResult: ...
|
||||
21
stdlib/unittest/util.pyi
Normal file
21
stdlib/unittest/util.pyi
Normal file
@@ -0,0 +1,21 @@
|
||||
from typing import Any, List, Sequence, Tuple, TypeVar
|
||||
|
||||
_T = TypeVar("_T")
|
||||
_Mismatch = Tuple[_T, _T, int]
|
||||
|
||||
_MAX_LENGTH: int
|
||||
_PLACEHOLDER_LEN: int
|
||||
_MIN_BEGIN_LEN: int
|
||||
_MIN_END_LEN: int
|
||||
_MIN_COMMON_LEN: int
|
||||
_MIN_DIFF_LEN: int
|
||||
|
||||
def _shorten(s: str, prefixlen: int, suffixlen: int) -> str: ...
|
||||
def _common_shorten_repr(*args: str) -> Tuple[str]: ...
|
||||
def safe_repr(obj: object, short: bool = ...) -> str: ...
|
||||
def strclass(cls: type) -> str: ...
|
||||
def sorted_list_difference(expected: Sequence[_T], actual: Sequence[_T]) -> Tuple[List[_T], List[_T]]: ...
|
||||
def unorderable_list_difference(expected: Sequence[_T], actual: Sequence[_T]) -> Tuple[List[_T], List[_T]]: ...
|
||||
def three_way_cmp(x: Any, y: Any) -> int: ...
|
||||
def _count_diff_all_purpose(actual: Sequence[_T], expected: Sequence[_T]) -> List[_Mismatch[_T]]: ...
|
||||
def _count_diff_hashable(actual: Sequence[_T], expected: Sequence[_T]) -> List[_Mismatch[_T]]: ...
|
||||
Reference in New Issue
Block a user