layermap 0.1.0

package/analyzers/project-map-python/typeshed/stdlib/unicodedata.pyi

@@ -0,0 +1,94 @@
+import sys
+from _typeshed import ReadOnlyBuffer
+from collections.abc import Iterator
+from typing import Final, Literal, TypeAlias, TypeVar, final, overload
+
+ucd_3_2_0: UCD
+unidata_version: Final[str]
+
+_T = TypeVar("_T")
+
+_NormalizationForm: TypeAlias = Literal["NFC", "NFD", "NFKC", "NFKD"]
+
+def bidirectional(chr: str, /) -> str: ...
+def category(chr: str, /) -> str: ...
+def combining(chr: str, /) -> int: ...
+
+@overload
+def decimal(chr: str, /) -> int: ...
+@overload
+def decimal(chr: str, default: _T, /) -> int | _T: ...
+
+def decomposition(chr: str, /) -> str: ...
+
+@overload
+def digit(chr: str, /) -> int: ...
+@overload
+def digit(chr: str, default: _T, /) -> int | _T: ...
+
+_EastAsianWidth: TypeAlias = Literal["F", "H", "W", "Na", "A", "N"]
+
+def east_asian_width(chr: str, /) -> _EastAsianWidth: ...
+def is_normalized(form: _NormalizationForm, unistr: str, /) -> bool: ...
+
+if sys.version_info >= (3, 15):
+    def block(chr: str, /) -> str: ...
+    def extended_pictographic(chr: str, /) -> bool: ...
+    def grapheme_cluster_break(chr: str, /) -> str: ...
+    def indic_conjunct_break(chr: str, /) -> str: ...
+    def isxidstart(chr: str, /) -> bool: ...
+    def isxidcontinue(chr: str, /) -> bool: ...
+    def iter_graphemes(unistr: str, start: int = 0, end: int = sys.maxsize, /) -> Iterator[str]: ...
+
+def lookup(name: str | ReadOnlyBuffer, /) -> str: ...
+def mirrored(chr: str, /) -> int: ...
+
+@overload
+def name(chr: str, /) -> str: ...
+@overload
+def name(chr: str, default: _T, /) -> str | _T: ...
+
+def normalize(form: _NormalizationForm, unistr: str, /) -> str: ...
+
+@overload
+def numeric(chr: str, /) -> float: ...
+@overload
+def numeric(chr: str, default: _T, /) -> float | _T: ...
+
+@final
+class UCD:
+    # The methods below are constructed from the same array in C
+    # (unicodedata_functions) and hence identical to the functions above.
+    unidata_version: str
+    def bidirectional(self, chr: str, /) -> str: ...
+    def category(self, chr: str, /) -> str: ...
+    def combining(self, chr: str, /) -> int: ...
+
+    @overload
+    def decimal(self, chr: str, /) -> int: ...
+    @overload
+    def decimal(self, chr: str, default: _T, /) -> int | _T: ...
+
+    def decomposition(self, chr: str, /) -> str: ...
+
+    @overload
+    def digit(self, chr: str, /) -> int: ...
+    @overload
+    def digit(self, chr: str, default: _T, /) -> int | _T: ...
+
+    def east_asian_width(self, chr: str, /) -> _EastAsianWidth: ...
+    def is_normalized(self, form: _NormalizationForm, unistr: str, /) -> bool: ...
+    def lookup(self, name: str | ReadOnlyBuffer, /) -> str: ...
+    def mirrored(self, chr: str, /) -> int: ...
+
+    @overload
+    def name(self, chr: str, /) -> str: ...
+    @overload
+    def name(self, chr: str, default: _T, /) -> str | _T: ...
+
+    def normalize(self, form: _NormalizationForm, unistr: str, /) -> str: ...
+
+    @overload
+    def numeric(self, chr: str, /) -> float: ...
+    @overload
+    def numeric(self, chr: str, default: _T, /) -> float | _T: ...

package/analyzers/project-map-python/typeshed/stdlib/unittest/__init__.pyi

@@ -0,0 +1,63 @@
+import sys
+from unittest.async_case import *
+
+from .case import (
+    FunctionTestCase as FunctionTestCase,
+    SkipTest as SkipTest,
+    TestCase as TestCase,
+    addModuleCleanup as addModuleCleanup,
+    expectedFailure as expectedFailure,
+    skip as skip,
+    skipIf as skipIf,
+    skipUnless as skipUnless,
+)
+from .loader import TestLoader as TestLoader, defaultTestLoader as defaultTestLoader
+from .main import TestProgram as TestProgram, main as main
+from .result import TestResult as TestResult
+from .runner import TextTestResult as TextTestResult, TextTestRunner as TextTestRunner
+from .signals import (
+    installHandler as installHandler,
+    registerResult as registerResult,
+    removeHandler as removeHandler,
+    removeResult as removeResult,
+)
+from .suite import BaseTestSuite as BaseTestSuite, TestSuite as TestSuite
+
+if sys.version_info >= (3, 11):
+    from .case import doModuleCleanups as doModuleCleanups, enterModuleContext as enterModuleContext
+
+__all__ = [
+    "IsolatedAsyncioTestCase",
+    "TestResult",
+    "TestCase",
+    "TestSuite",
+    "TextTestRunner",
+    "TestLoader",
+    "FunctionTestCase",
+    "main",
+    "defaultTestLoader",
+    "SkipTest",
+    "skip",
+    "skipIf",
+    "skipUnless",
+    "expectedFailure",
+    "TextTestResult",
+    "installHandler",
+    "registerResult",
+    "removeResult",
+    "removeHandler",
+    "addModuleCleanup",
+]
+
+if sys.version_info < (3, 13):
+    from .loader import findTestCases as findTestCases, getTestCaseNames as getTestCaseNames, makeSuite as makeSuite
+
+    __all__ += ["getTestCaseNames", "makeSuite", "findTestCases"]
+
+if sys.version_info >= (3, 11):
+    __all__ += ["enterModuleContext", "doModuleCleanups"]
+
+if sys.version_info < (3, 12):
+    def load_tests(loader: TestLoader, tests: TestSuite, pattern: str | None) -> TestSuite: ...
+
+def __dir__() -> set[str]: ...

package/analyzers/project-map-python/typeshed/stdlib/unittest/_log.pyi

@@ -0,0 +1,29 @@
+import logging
+import sys
+from types import TracebackType
+from typing import ClassVar, Generic, NamedTuple, TypeVar
+from unittest.case import TestCase, _BaseTestCaseContext
+
+_L = TypeVar("_L", None, _LoggingWatcher)
+
+class _LoggingWatcher(NamedTuple):
+    records: list[logging.LogRecord]
+    output: list[str]
+
+class _AssertLogsContext(_BaseTestCaseContext, Generic[_L]):
+    LOGGING_FORMAT: ClassVar[str]
+    logger_name: str
+    level: int
+    msg: None
+    no_logs: bool
+    if sys.version_info >= (3, 15):
+        def __init__(
+            self, test_case: TestCase, logger_name: str, level: int, no_logs: bool, formatter: logging.Formatter | None = None
+        ) -> None: ...
+    else:
+        def __init__(self, test_case: TestCase, logger_name: str, level: int, no_logs: bool) -> None: ...
+
+    def __enter__(self) -> _L: ...
+    def __exit__(
+        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, tb: TracebackType | None
+    ) -> bool | None: ...

package/analyzers/project-map-python/typeshed/stdlib/unittest/async_case.pyi

@@ -0,0 +1,24 @@
+import sys
+from asyncio.events import AbstractEventLoop
+from collections.abc import Awaitable, Callable
+from typing import ParamSpec, TypeVar
+
+from .case import TestCase
+
+if sys.version_info >= (3, 11):
+    from contextlib import AbstractAsyncContextManager
+
+_T = TypeVar("_T")
+_P = ParamSpec("_P")
+
+class IsolatedAsyncioTestCase(TestCase):
+    if sys.version_info >= (3, 13):
+        loop_factory: Callable[[], AbstractEventLoop] | None = None
+
+    async def asyncSetUp(self) -> None: ...
+    async def asyncTearDown(self) -> None: ...
+    def addAsyncCleanup(self, func: Callable[_P, Awaitable[object]], /, *args: _P.args, **kwargs: _P.kwargs) -> None: ...
+    if sys.version_info >= (3, 11):
+        async def enterAsyncContext(self, cm: AbstractAsyncContextManager[_T]) -> _T: ...
+
+    def __del__(self) -> None: ...

package/analyzers/project-map-python/typeshed/stdlib/unittest/case.pyi

@@ -0,0 +1,353 @@
+import logging
+import sys
+import unittest.result
+from _typeshed import SupportsDunderGE, SupportsDunderGT, SupportsDunderLE, SupportsDunderLT, SupportsRSub, SupportsSub
+from builtins import _ClassInfo
+from collections.abc import Callable, Container, Iterable, Mapping, Sequence, Set as AbstractSet
+from contextlib import AbstractContextManager
+from re import Pattern
+from types import GenericAlias, TracebackType
+from typing import (
+    Any,
+    AnyStr,
+    Final,
+    Generic,
+    NoReturn,
+    ParamSpec,
+    Protocol,
+    SupportsAbs,
+    SupportsRound,
+    TypeVar,
+    overload,
+    type_check_only,
+)
+from typing_extensions import Never, Self
+from unittest._log import _AssertLogsContext, _LoggingWatcher
+from warnings import WarningMessage
+
+_T = TypeVar("_T")
+_S = TypeVar("_S", bound=SupportsSub[Any, Any])
+_E = TypeVar("_E", bound=BaseException)
+_FT = TypeVar("_FT", bound=Callable[..., Any])
+_SB = TypeVar("_SB", str, bytes, bytearray)
+_P = ParamSpec("_P")
+
+DIFF_OMITTED: Final[str]
+
+class _BaseTestCaseContext:
+    test_case: TestCase
+    def __init__(self, test_case: TestCase) -> None: ...
+
+class _AssertRaisesBaseContext(_BaseTestCaseContext):
+    expected: type[BaseException] | tuple[type[BaseException], ...]
+    expected_regex: Pattern[str] | None
+    obj_name: str | None
+    msg: str | None
+
+    def __init__(
+        self,
+        expected: type[BaseException] | tuple[type[BaseException], ...],
+        test_case: TestCase,
+        expected_regex: str | Pattern[str] | None = None,
+    ) -> None: ...
+
+    # This returns Self if args is the empty list, and None otherwise.
+    # but it's not possible to construct an overload which expresses that
+    def handle(self, name: str, args: list[Any], kwargs: dict[str, Any]) -> Any: ...
+
+def addModuleCleanup(function: Callable[_P, object], /, *args: _P.args, **kwargs: _P.kwargs) -> None: ...
+def doModuleCleanups() -> None: ...
+
+if sys.version_info >= (3, 11):
+    def enterModuleContext(cm: AbstractContextManager[_T]) -> _T: ...
+
+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: ...
+
+@type_check_only
+class _SupportsAbsAndDunderGE(SupportsDunderGE[Any], SupportsAbs[Any], Protocol): ...
+
+class TestCase:
+    failureException: type[BaseException]
+    longMessage: bool
+    maxDiff: int | None
+    # undocumented
+    _testMethodName: str
+    # undocumented
+    _testMethodDoc: str
+    def __init__(self, methodName: str = "runTest") -> None: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __hash__(self) -> int: ...
+    def setUp(self) -> None: ...
+    def tearDown(self) -> None: ...
+    @classmethod
+    def setUpClass(cls) -> None: ...
+    @classmethod
+    def tearDownClass(cls) -> None: ...
+    def run(self, result: unittest.result.TestResult | None = None) -> unittest.result.TestResult | None: ...
+    def __call__(self, result: unittest.result.TestResult | None = ...) -> unittest.result.TestResult | None: ...
+    def skipTest(self, reason: Any) -> NoReturn: ...
+    def subTest(self, msg: Any = ..., **params: Any) -> AbstractContextManager[None]: ...
+    def debug(self) -> None: ...
+    if sys.version_info < (3, 11):
+        def _addSkip(self, result: unittest.result.TestResult, test_case: TestCase, reason: str) -> None: ...
+
+    def assertEqual(self, first: Any, second: Any, msg: Any = None) -> None: ...
+    def assertNotEqual(self, first: Any, second: Any, msg: Any = None) -> None: ...
+    def assertTrue(self, expr: Any, msg: Any = None) -> None: ...
+    def assertFalse(self, expr: Any, msg: Any = None) -> None: ...
+    def assertIs(self, expr1: object, expr2: object, msg: Any = None) -> None: ...
+    def assertIsNot(self, expr1: object, expr2: object, msg: Any = None) -> None: ...
+    def assertIsNone(self, obj: object, msg: Any = None) -> None: ...
+    def assertIsNotNone(self, obj: object, msg: Any = None) -> None: ...
+    def assertIn(self, member: Any, container: Iterable[Any] | Container[Any], msg: Any = None) -> None: ...
+    def assertNotIn(self, member: Any, container: Iterable[Any] | Container[Any], msg: Any = None) -> None: ...
+    def assertIsInstance(self, obj: object, cls: _ClassInfo, msg: Any = None) -> None: ...
+    def assertNotIsInstance(self, obj: object, cls: _ClassInfo, msg: Any = None) -> None: ...
+
+    @overload
+    def assertGreater(self, a: SupportsDunderGT[_T], b: _T, msg: Any = None) -> None: ...
+    @overload
+    def assertGreater(self, a: _T, b: SupportsDunderLT[_T], msg: Any = None) -> None: ...
+
+    @overload
+    def assertGreaterEqual(self, a: SupportsDunderGE[_T], b: _T, msg: Any = None) -> None: ...
+    @overload
+    def assertGreaterEqual(self, a: _T, b: SupportsDunderLE[_T], msg: Any = None) -> None: ...
+
+    @overload
+    def assertLess(self, a: SupportsDunderLT[_T], b: _T, msg: Any = None) -> None: ...
+    @overload
+    def assertLess(self, a: _T, b: SupportsDunderGT[_T], msg: Any = None) -> None: ...
+
+    @overload
+    def assertLessEqual(self, a: SupportsDunderLE[_T], b: _T, msg: Any = None) -> None: ...
+    @overload
+    def assertLessEqual(self, a: _T, b: SupportsDunderGE[_T], msg: Any = None) -> None: ...
+
+    # `assertRaises`, `assertRaisesRegex`, and `assertRaisesRegexp`
+    # are not using `ParamSpec` intentionally,
+    # because they might be used with explicitly wrong arg types to raise some error in tests.
+    @overload
+    def assertRaises(
+        self,
+        expected_exception: type[BaseException] | tuple[type[BaseException], ...],
+        callable: Callable[..., object],
+        *args: Any,
+        **kwargs: Any,
+    ) -> None: ...
+    @overload
+    def assertRaises(
+        self, expected_exception: type[_E] | tuple[type[_E], ...], *, msg: Any = ...
+    ) -> _AssertRaisesContext[_E]: ...
+
+    @overload
+    def assertRaisesRegex(
+        self,
+        expected_exception: type[BaseException] | tuple[type[BaseException], ...],
+        expected_regex: str | Pattern[str],
+        callable: Callable[..., object],
+        *args: Any,
+        **kwargs: Any,
+    ) -> None: ...
+    @overload
+    def assertRaisesRegex(
+        self, expected_exception: type[_E] | tuple[type[_E], ...], expected_regex: str | Pattern[str], *, msg: Any = ...
+    ) -> _AssertRaisesContext[_E]: ...
+
+    @overload
+    def assertWarns(
+        self,
+        expected_warning: type[Warning] | tuple[type[Warning], ...],
+        callable: Callable[_P, object],
+        *args: _P.args,
+        **kwargs: _P.kwargs,
+    ) -> None: ...
+    @overload
+    def assertWarns(
+        self, expected_warning: type[Warning] | tuple[type[Warning], ...], *, msg: Any = ...
+    ) -> _AssertWarnsContext: ...
+
+    @overload
+    def assertWarnsRegex(
+        self,
+        expected_warning: type[Warning] | tuple[type[Warning], ...],
+        expected_regex: str | Pattern[str],
+        callable: Callable[_P, object],
+        *args: _P.args,
+        **kwargs: _P.kwargs,
+    ) -> None: ...
+    @overload
+    def assertWarnsRegex(
+        self, expected_warning: type[Warning] | tuple[type[Warning], ...], expected_regex: str | Pattern[str], *, msg: Any = ...
+    ) -> _AssertWarnsContext: ...
+
+    if sys.version_info >= (3, 15):
+        def assertLogs(
+            self,
+            logger: str | logging.Logger | None = None,
+            level: int | str | None = None,
+            formatter: logging.Formatter | None = None,
+        ) -> _AssertLogsContext[_LoggingWatcher]: ...
+    else:
+        def assertLogs(
+            self, logger: str | logging.Logger | None = None, level: int | str | None = None
+        ) -> _AssertLogsContext[_LoggingWatcher]: ...
+
+    def assertNoLogs(
+        self, logger: str | logging.Logger | None = None, level: int | str | None = None
+    ) -> _AssertLogsContext[None]: ...
+
+    @overload
+    def assertAlmostEqual(self, first: _S, second: _S, places: None, msg: Any, delta: _SupportsAbsAndDunderGE) -> None: ...
+    @overload
+    def assertAlmostEqual(
+        self, first: _S, second: _S, places: None = None, msg: Any = None, *, delta: _SupportsAbsAndDunderGE
+    ) -> None: ...
+    @overload
+    def assertAlmostEqual(
+        self,
+        first: SupportsSub[_T, SupportsAbs[SupportsRound[object]]],
+        second: _T,
+        places: int | None = None,
+        msg: Any = None,
+        delta: None = None,
+    ) -> None: ...
+    @overload
+    def assertAlmostEqual(
+        self,
+        first: _T,
+        second: SupportsRSub[_T, SupportsAbs[SupportsRound[object]]],
+        places: int | None = None,
+        msg: Any = None,
+        delta: None = None,
+    ) -> None: ...
+
+    @overload
+    def assertNotAlmostEqual(self, first: _S, second: _S, places: None, msg: Any, delta: _SupportsAbsAndDunderGE) -> None: ...
+    @overload
+    def assertNotAlmostEqual(
+        self, first: _S, second: _S, places: None = None, msg: Any = None, *, delta: _SupportsAbsAndDunderGE
+    ) -> None: ...
+    @overload
+    def assertNotAlmostEqual(
+        self,
+        first: SupportsSub[_T, SupportsAbs[SupportsRound[object]]],
+        second: _T,
+        places: int | None = None,
+        msg: Any = None,
+        delta: None = None,
+    ) -> None: ...
+    @overload
+    def assertNotAlmostEqual(
+        self,
+        first: _T,
+        second: SupportsRSub[_T, SupportsAbs[SupportsRound[object]]],
+        places: int | None = None,
+        msg: Any = None,
+        delta: None = None,
+    ) -> None: ...
+
+    def assertRegex(self, text: AnyStr, expected_regex: AnyStr | Pattern[AnyStr], msg: Any = None) -> None: ...
+    def assertNotRegex(self, text: AnyStr, unexpected_regex: AnyStr | Pattern[AnyStr], msg: Any = None) -> None: ...
+    def assertCountEqual(self, first: Iterable[Any], second: Iterable[Any], msg: Any = None) -> None: ...
+    def addTypeEqualityFunc(self, typeobj: type[Any], function: Callable[..., None]) -> None: ...
+    def assertMultiLineEqual(self, first: str, second: str, msg: Any = None) -> None: ...
+    def assertSequenceEqual(
+        self, seq1: Sequence[Any], seq2: Sequence[Any], msg: Any = None, seq_type: type[Sequence[Any]] | None = None
+    ) -> None: ...
+    def assertListEqual(self, list1: list[Any], list2: list[Any], msg: Any = None) -> None: ...
+    def assertTupleEqual(self, tuple1: tuple[Any, ...], tuple2: tuple[Any, ...], msg: Any = None) -> None: ...
+    def assertSetEqual(self, set1: AbstractSet[object], set2: AbstractSet[object], msg: Any = None) -> None: ...
+    # assertDictEqual accepts only true dict instances. We can't use that here, since that would make
+    # assertDictEqual incompatible with TypedDict.
+    def assertDictEqual(self, d1: Mapping[Any, object], d2: Mapping[Any, object], msg: Any = None) -> None: ...
+    def fail(self, msg: Any = None) -> NoReturn: ...
+    def countTestCases(self) -> int: ...
+    def defaultTestResult(self) -> unittest.result.TestResult: ...
+    def id(self) -> str: ...
+    def shortDescription(self) -> str | None: ...
+    def addCleanup(self, function: Callable[_P, object], /, *args: _P.args, **kwargs: _P.kwargs) -> None: ...
+
+    if sys.version_info >= (3, 11):
+        def enterContext(self, cm: AbstractContextManager[_T]) -> _T: ...
+
+    def doCleanups(self) -> None: ...
+    @classmethod
+    def addClassCleanup(cls, function: Callable[_P, object], /, *args: _P.args, **kwargs: _P.kwargs) -> None: ...
+    @classmethod
+    def doClassCleanups(cls) -> None: ...
+
+    if sys.version_info >= (3, 11):
+        @classmethod
+        def enterClassContext(cls, cm: AbstractContextManager[_T]) -> _T: ...
+
+    def _formatMessage(self, msg: str | None, standardMsg: str) -> str: ...  # undocumented
+    def _getAssertEqualityFunc(self, first: Any, second: Any) -> Callable[..., None]: ...  # undocumented
+    if sys.version_info < (3, 12):
+        failUnlessEqual = assertEqual
+        assertEquals = assertEqual
+        failIfEqual = assertNotEqual
+        assertNotEquals = assertNotEqual
+        failUnless = assertTrue
+        assert_ = assertTrue
+        failIf = assertFalse
+        failUnlessRaises = assertRaises
+        failUnlessAlmostEqual = assertAlmostEqual
+        assertAlmostEquals = assertAlmostEqual
+        failIfAlmostEqual = assertNotAlmostEqual
+        assertNotAlmostEquals = assertNotAlmostEqual
+        assertRegexpMatches = assertRegex
+        assertNotRegexpMatches = assertNotRegex
+        assertRaisesRegexp = assertRaisesRegex
+        def assertDictContainsSubset(
+            self, subset: Mapping[Any, Any], dictionary: Mapping[Any, Any], msg: object = None
+        ) -> None: ...
+
+    # Runtime has *args, **kwargs, but will error if any are supplied
+    def __init_subclass__(cls, *args: Never, **kwargs: Never) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def assertIsSubclass(self, cls: type, superclass: type | tuple[type, ...], msg: Any = None) -> None: ...
+        def assertNotIsSubclass(self, cls: type, superclass: type | tuple[type, ...], msg: Any = None) -> None: ...
+        def assertHasAttr(self, obj: object, name: str, msg: Any = None) -> None: ...
+        def assertNotHasAttr(self, obj: object, name: str, msg: Any = None) -> None: ...
+        def assertStartsWith(self, s: _SB, prefix: _SB | tuple[_SB, ...], msg: Any = None) -> None: ...
+        def assertNotStartsWith(self, s: _SB, prefix: _SB | tuple[_SB, ...], msg: Any = None) -> None: ...
+        def assertEndsWith(self, s: _SB, suffix: _SB | tuple[_SB, ...], msg: Any = None) -> None: ...
+        def assertNotEndsWith(self, s: _SB, suffix: _SB | tuple[_SB, ...], msg: Any = None) -> None: ...
+
+class FunctionTestCase(TestCase):
+    def __init__(
+        self,
+        testFunc: Callable[[], object],
+        setUp: Callable[[], object] | None = None,
+        tearDown: Callable[[], object] | None = None,
+        description: str | None = None,
+    ) -> None: ...
+    def runTest(self) -> None: ...
+    def __hash__(self) -> int: ...
+    def __eq__(self, other: object) -> bool: ...
+
+class _AssertRaisesContext(_AssertRaisesBaseContext, Generic[_E]):
+    exception: _E
+    def __enter__(self) -> Self: ...
+    def __exit__(
+        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, tb: TracebackType | None
+    ) -> bool: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+
+class _AssertWarnsContext(_AssertRaisesBaseContext):
+    warning: WarningMessage
+    filename: str
+    lineno: int
+    warnings: list[WarningMessage]
+    def __enter__(self) -> Self: ...
+    def __exit__(
+        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, tb: TracebackType | None
+    ) -> None: ...

package/analyzers/project-map-python/typeshed/stdlib/unittest/loader.pyi

@@ -0,0 +1,55 @@
+import sys
+import unittest.case
+import unittest.suite
+from collections.abc import Callable, Sequence
+from re import Pattern
+from types import ModuleType
+from typing import Any, Final, TypeAlias
+from typing_extensions import deprecated
+
+_SortComparisonMethod: TypeAlias = Callable[[str, str], int]
+_SuiteClass: TypeAlias = Callable[[list[unittest.case.TestCase]], unittest.suite.TestSuite]
+
+VALID_MODULE_NAME: Final[Pattern[str]]
+
+class TestLoader:
+    errors: list[type[BaseException]]
+    testMethodPrefix: str
+    sortTestMethodsUsing: _SortComparisonMethod
+    testNamePatterns: list[str] | None
+    suiteClass: _SuiteClass
+    def loadTestsFromTestCase(self, testCaseClass: type[unittest.case.TestCase]) -> unittest.suite.TestSuite: ...
+    if sys.version_info >= (3, 12):
+        def loadTestsFromModule(self, module: ModuleType, *, pattern: str | None = None) -> unittest.suite.TestSuite: ...
+    else:
+        def loadTestsFromModule(self, module: ModuleType, *args: Any, pattern: str | None = None) -> unittest.suite.TestSuite: ...
+
+    def loadTestsFromName(self, name: str, module: ModuleType | None = None) -> unittest.suite.TestSuite: ...
+    def loadTestsFromNames(self, names: Sequence[str], module: ModuleType | None = None) -> unittest.suite.TestSuite: ...
+    def getTestCaseNames(self, testCaseClass: type[unittest.case.TestCase]) -> Sequence[str]: ...
+    def discover(
+        self, start_dir: str, pattern: str = "test*.py", top_level_dir: str | None = None
+    ) -> unittest.suite.TestSuite: ...
+    def _match_path(self, path: str, full_path: str, pattern: str) -> bool: ...
+
+defaultTestLoader: TestLoader
+
+if sys.version_info < (3, 13):
+    @deprecated("Deprecated since Python 3.11; removed in Python 3.13.")
+    def getTestCaseNames(
+        testCaseClass: type[unittest.case.TestCase],
+        prefix: str,
+        sortUsing: _SortComparisonMethod = ...,
+        testNamePatterns: list[str] | None = None,
+    ) -> Sequence[str]: ...
+    @deprecated("Deprecated since Python 3.11; removed in Python 3.13.")
+    def makeSuite(
+        testCaseClass: type[unittest.case.TestCase],
+        prefix: str = "test",
+        sortUsing: _SortComparisonMethod = ...,
+        suiteClass: _SuiteClass = ...,
+    ) -> unittest.suite.TestSuite: ...
+    @deprecated("Deprecated since Python 3.11; removed in Python 3.13.")
+    def findTestCases(
+        module: ModuleType, prefix: str = "test", sortUsing: _SortComparisonMethod = ..., suiteClass: _SuiteClass = ...
+    ) -> unittest.suite.TestSuite: ...