jaclang 0.7.33__py3-none-any.whl → 0.8.0__py3-none-any.whl

jaclang/vendor/mypy/typeshed/stdlib/typing_extensions.pyi

@@ -1,509 +0,0 @@
-import abc
-import sys
-import typing
-from _collections_abc import dict_items, dict_keys, dict_values
-from _typeshed import IdentityFunction
-from typing import (  # noqa: Y022,Y037,Y038,Y039
-    IO as IO,
-    TYPE_CHECKING as TYPE_CHECKING,
-    AbstractSet as AbstractSet,
-    Any as Any,
-    AnyStr as AnyStr,
-    AsyncContextManager as AsyncContextManager,
-    AsyncGenerator as AsyncGenerator,
-    AsyncIterable as AsyncIterable,
-    AsyncIterator as AsyncIterator,
-    Awaitable as Awaitable,
-    BinaryIO as BinaryIO,
-    Callable as Callable,
-    ChainMap as ChainMap,
-    ClassVar as ClassVar,
-    Collection as Collection,
-    Container as Container,
-    ContextManager as ContextManager,
-    Coroutine as Coroutine,
-    Counter as Counter,
-    DefaultDict as DefaultDict,
-    Deque as Deque,
-    Dict as Dict,
-    ForwardRef as ForwardRef,
-    FrozenSet as FrozenSet,
-    Generator as Generator,
-    Generic as Generic,
-    Hashable as Hashable,
-    ItemsView as ItemsView,
-    Iterable as Iterable,
-    Iterator as Iterator,
-    KeysView as KeysView,
-    List as List,
-    Mapping as Mapping,
-    MappingView as MappingView,
-    Match as Match,
-    MutableMapping as MutableMapping,
-    MutableSequence as MutableSequence,
-    MutableSet as MutableSet,
-    NoReturn as NoReturn,
-    Optional as Optional,
-    Pattern as Pattern,
-    Reversible as Reversible,
-    Sequence as Sequence,
-    Set as Set,
-    Sized as Sized,
-    SupportsAbs as SupportsAbs,
-    SupportsBytes as SupportsBytes,
-    SupportsComplex as SupportsComplex,
-    SupportsFloat as SupportsFloat,
-    SupportsInt as SupportsInt,
-    SupportsRound as SupportsRound,
-    Text as Text,
-    TextIO as TextIO,
-    Tuple as Tuple,
-    Type as Type,
-    Union as Union,
-    ValuesView as ValuesView,
-    _Alias,
-    cast as cast,
-    no_type_check as no_type_check,
-    no_type_check_decorator as no_type_check_decorator,
-    overload as overload,
-    type_check_only,
-)
-
-if sys.version_info >= (3, 10):
-    from types import UnionType
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
-
-__all__ = [
-    "Any",
-    "Buffer",
-    "ClassVar",
-    "Concatenate",
-    "Final",
-    "LiteralString",
-    "ParamSpec",
-    "ParamSpecArgs",
-    "ParamSpecKwargs",
-    "Self",
-    "Type",
-    "TypeVar",
-    "TypeVarTuple",
-    "Unpack",
-    "Awaitable",
-    "AsyncIterator",
-    "AsyncIterable",
-    "Coroutine",
-    "AsyncGenerator",
-    "AsyncContextManager",
-    "ChainMap",
-    "ContextManager",
-    "Counter",
-    "Deque",
-    "DefaultDict",
-    "NamedTuple",
-    "OrderedDict",
-    "TypedDict",
-    "SupportsIndex",
-    "SupportsAbs",
-    "SupportsRound",
-    "SupportsBytes",
-    "SupportsComplex",
-    "SupportsFloat",
-    "SupportsInt",
-    "Annotated",
-    "assert_never",
-    "assert_type",
-    "dataclass_transform",
-    "deprecated",
-    "final",
-    "IntVar",
-    "is_typeddict",
-    "Literal",
-    "NewType",
-    "overload",
-    "override",
-    "Protocol",
-    "reveal_type",
-    "runtime",
-    "runtime_checkable",
-    "Text",
-    "TypeAlias",
-    "TypeAliasType",
-    "TypeGuard",
-    "TYPE_CHECKING",
-    "Never",
-    "NoReturn",
-    "Required",
-    "NotRequired",
-    "clear_overloads",
-    "get_args",
-    "get_origin",
-    "get_original_bases",
-    "get_overloads",
-    "get_type_hints",
-    "AbstractSet",
-    "AnyStr",
-    "BinaryIO",
-    "Callable",
-    "Collection",
-    "Container",
-    "Dict",
-    "Doc",
-    "ForwardRef",
-    "FrozenSet",
-    "Generator",
-    "Generic",
-    "Hashable",
-    "IO",
-    "ItemsView",
-    "Iterable",
-    "Iterator",
-    "KeysView",
-    "List",
-    "Mapping",
-    "MappingView",
-    "Match",
-    "MutableMapping",
-    "MutableSequence",
-    "MutableSet",
-    "Optional",
-    "Pattern",
-    "Reversible",
-    "Sequence",
-    "Set",
-    "Sized",
-    "TextIO",
-    "Tuple",
-    "Union",
-    "ValuesView",
-    "cast",
-    "get_protocol_members",
-    "is_protocol",
-    "no_type_check",
-    "no_type_check_decorator",
-    "ReadOnly",
-    "TypeIs",
-]
-
-_T = typing.TypeVar("_T")
-_F = typing.TypeVar("_F", bound=Callable[..., Any])
-_TC = typing.TypeVar("_TC", bound=type[object])
-
-# unfortunately we have to duplicate this class definition from typing.pyi or we break pytype
-class _SpecialForm:
-    def __getitem__(self, parameters: Any) -> object: ...
-    if sys.version_info >= (3, 10):
-        def __or__(self, other: Any) -> _SpecialForm: ...
-        def __ror__(self, other: Any) -> _SpecialForm: ...
-
-# Do not import (and re-export) Protocol or runtime_checkable from
-# typing module because type checkers need to be able to distinguish
-# typing.Protocol and typing_extensions.Protocol so they can properly
-# warn users about potential runtime exceptions when using typing.Protocol
-# on older versions of Python.
-Protocol: _SpecialForm
-
-def runtime_checkable(cls: _TC) -> _TC: ...
-
-# This alias for above is kept here for backwards compatibility.
-runtime = runtime_checkable
-Final: _SpecialForm
-
-def final(f: _F) -> _F: ...
-
-Literal: _SpecialForm
-
-def IntVar(name: str) -> Any: ...  # returns a new TypeVar
-
-# Internal mypy fallback type for all typed dicts (does not exist at runtime)
-# N.B. Keep this mostly in sync with typing._TypedDict/mypy_extensions._TypedDict
-@type_check_only
-class _TypedDict(Mapping[str, object], metaclass=abc.ABCMeta):
-    __required_keys__: ClassVar[frozenset[str]]
-    __optional_keys__: ClassVar[frozenset[str]]
-    __total__: ClassVar[bool]
-    __orig_bases__: ClassVar[tuple[Any, ...]]
-    # PEP 705
-    __readonly_keys__: ClassVar[frozenset[str]]
-    __mutable_keys__: ClassVar[frozenset[str]]
-    # PEP 728
-    __closed__: ClassVar[bool]
-    __extra_items__: ClassVar[Any]
-    def copy(self) -> Self: ...
-    # Using Never so that only calls using mypy plugin hook that specialize the signature
-    # can go through.
-    def setdefault(self, k: Never, default: object) -> object: ...
-    # Mypy plugin hook for 'pop' expects that 'default' has a type variable type.
-    def pop(self, k: Never, default: _T = ...) -> object: ...  # pyright: ignore[reportInvalidTypeVarUse]
-    def update(self: _T, m: _T, /) -> None: ...
-    def items(self) -> dict_items[str, object]: ...
-    def keys(self) -> dict_keys[str, object]: ...
-    def values(self) -> dict_values[str, object]: ...
-    def __delitem__(self, k: Never) -> None: ...
-    if sys.version_info >= (3, 9):
-        @overload
-        def __or__(self, value: Self, /) -> Self: ...
-        @overload
-        def __or__(self, value: dict[str, Any], /) -> dict[str, object]: ...
-        @overload
-        def __ror__(self, value: Self, /) -> Self: ...
-        @overload
-        def __ror__(self, value: dict[str, Any], /) -> dict[str, object]: ...
-        # supposedly incompatible definitions of `__ior__` and `__or__`:
-        def __ior__(self, value: Self, /) -> Self: ...  # type: ignore[misc]
-
-# TypedDict is a (non-subscriptable) special form.
-TypedDict: object
-
-OrderedDict = _Alias()
-
-def get_type_hints(
-    obj: Callable[..., Any],
-    globalns: dict[str, Any] | None = None,
-    localns: dict[str, Any] | None = None,
-    include_extras: bool = False,
-) -> dict[str, Any]: ...
-def get_args(tp: Any) -> tuple[Any, ...]: ...
-
-if sys.version_info >= (3, 10):
-    @overload
-    def get_origin(tp: UnionType) -> type[UnionType]: ...
-
-if sys.version_info >= (3, 9):
-    @overload
-    def get_origin(tp: GenericAlias) -> type: ...
-
-@overload
-def get_origin(tp: ParamSpecArgs | ParamSpecKwargs) -> ParamSpec: ...
-@overload
-def get_origin(tp: Any) -> Any | None: ...
-
-Annotated: _SpecialForm
-_AnnotatedAlias: Any  # undocumented
-
-@runtime_checkable
-class SupportsIndex(Protocol, metaclass=abc.ABCMeta):
-    @abc.abstractmethod
-    def __index__(self) -> int: ...
-
-# New and changed things in 3.10
-if sys.version_info >= (3, 10):
-    from typing import (
-        Concatenate as Concatenate,
-        ParamSpecArgs as ParamSpecArgs,
-        ParamSpecKwargs as ParamSpecKwargs,
-        TypeAlias as TypeAlias,
-        TypeGuard as TypeGuard,
-        is_typeddict as is_typeddict,
-    )
-else:
-    @final
-    class ParamSpecArgs:
-        @property
-        def __origin__(self) -> ParamSpec: ...
-        def __init__(self, origin: ParamSpec) -> None: ...
-
-    @final
-    class ParamSpecKwargs:
-        @property
-        def __origin__(self) -> ParamSpec: ...
-        def __init__(self, origin: ParamSpec) -> None: ...
-
-    Concatenate: _SpecialForm
-    TypeAlias: _SpecialForm
-    TypeGuard: _SpecialForm
-    def is_typeddict(tp: object) -> bool: ...
-
-# New and changed things in 3.11
-if sys.version_info >= (3, 11):
-    from typing import (
-        LiteralString as LiteralString,
-        NamedTuple as NamedTuple,
-        Never as Never,
-        NewType as NewType,
-        NotRequired as NotRequired,
-        Required as Required,
-        Self as Self,
-        Unpack as Unpack,
-        assert_never as assert_never,
-        assert_type as assert_type,
-        clear_overloads as clear_overloads,
-        dataclass_transform as dataclass_transform,
-        get_overloads as get_overloads,
-        reveal_type as reveal_type,
-    )
-else:
-    Self: _SpecialForm
-    Never: _SpecialForm
-    def reveal_type(obj: _T, /) -> _T: ...
-    def assert_never(arg: Never, /) -> Never: ...
-    def assert_type(val: _T, typ: Any, /) -> _T: ...
-    def clear_overloads() -> None: ...
-    def get_overloads(func: Callable[..., object]) -> Sequence[Callable[..., object]]: ...
-
-    Required: _SpecialForm
-    NotRequired: _SpecialForm
-    LiteralString: _SpecialForm
-    Unpack: _SpecialForm
-
-    def dataclass_transform(
-        *,
-        eq_default: bool = True,
-        order_default: bool = False,
-        kw_only_default: bool = False,
-        frozen_default: bool = False,
-        field_specifiers: tuple[type[Any] | Callable[..., Any], ...] = (),
-        **kwargs: object,
-    ) -> IdentityFunction: ...
-
-    class NamedTuple(tuple[Any, ...]):
-        if sys.version_info < (3, 9):
-            _field_types: ClassVar[dict[str, type]]
-        _field_defaults: ClassVar[dict[str, Any]]
-        _fields: ClassVar[tuple[str, ...]]
-        __orig_bases__: ClassVar[tuple[Any, ...]]
-        @overload
-        def __init__(self, typename: str, fields: Iterable[tuple[str, Any]] = ...) -> None: ...
-        @overload
-        def __init__(self, typename: str, fields: None = None, **kwargs: Any) -> None: ...
-        @classmethod
-        def _make(cls, iterable: Iterable[Any]) -> Self: ...
-        def _asdict(self) -> dict[str, Any]: ...
-        def _replace(self, **kwargs: Any) -> Self: ...
-
-    class NewType:
-        def __init__(self, name: str, tp: Any) -> None: ...
-        def __call__(self, obj: _T, /) -> _T: ...
-        __supertype__: type | NewType
-        if sys.version_info >= (3, 10):
-            def __or__(self, other: Any) -> _SpecialForm: ...
-            def __ror__(self, other: Any) -> _SpecialForm: ...
-
-# New things in 3.xx
-# The `default` parameter was added to TypeVar, ParamSpec, and TypeVarTuple (PEP 696)
-# The `infer_variance` parameter was added to TypeVar in 3.12 (PEP 695)
-# typing_extensions.override (PEP 698)
-@final
-class TypeVar:
-    @property
-    def __name__(self) -> str: ...
-    @property
-    def __bound__(self) -> Any | None: ...
-    @property
-    def __constraints__(self) -> tuple[Any, ...]: ...
-    @property
-    def __covariant__(self) -> bool: ...
-    @property
-    def __contravariant__(self) -> bool: ...
-    @property
-    def __infer_variance__(self) -> bool: ...
-    @property
-    def __default__(self) -> Any | None: ...
-    def __init__(
-        self,
-        name: str,
-        *constraints: Any,
-        bound: Any | None = None,
-        covariant: bool = False,
-        contravariant: bool = False,
-        default: Any | None = None,
-        infer_variance: bool = False,
-    ) -> None: ...
-    if sys.version_info >= (3, 10):
-        def __or__(self, right: Any) -> _SpecialForm: ...
-        def __ror__(self, left: Any) -> _SpecialForm: ...
-    if sys.version_info >= (3, 11):
-        def __typing_subst__(self, arg: Any) -> Any: ...
-
-@final
-class ParamSpec:
-    @property
-    def __name__(self) -> str: ...
-    @property
-    def __bound__(self) -> Any | None: ...
-    @property
-    def __covariant__(self) -> bool: ...
-    @property
-    def __contravariant__(self) -> bool: ...
-    @property
-    def __infer_variance__(self) -> bool: ...
-    @property
-    def __default__(self) -> Any | None: ...
-    def __init__(
-        self,
-        name: str,
-        *,
-        bound: None | type[Any] | str = None,
-        contravariant: bool = False,
-        covariant: bool = False,
-        default: type[Any] | str | None = None,
-    ) -> None: ...
-    @property
-    def args(self) -> ParamSpecArgs: ...
-    @property
-    def kwargs(self) -> ParamSpecKwargs: ...
-
-@final
-class TypeVarTuple:
-    @property
-    def __name__(self) -> str: ...
-    @property
-    def __default__(self) -> Any | None: ...
-    def __init__(self, name: str, *, default: Any | None = None) -> None: ...
-    def __iter__(self) -> Any: ...  # Unpack[Self]
-
-class deprecated:
-    message: LiteralString
-    category: type[Warning] | None
-    stacklevel: int
-    def __init__(self, message: LiteralString, /, *, category: type[Warning] | None = ..., stacklevel: int = 1) -> None: ...
-    def __call__(self, arg: _T, /) -> _T: ...
-
-if sys.version_info >= (3, 12):
-    from collections.abc import Buffer as Buffer
-    from types import get_original_bases as get_original_bases
-    from typing import TypeAliasType as TypeAliasType, override as override
-else:
-    def override(arg: _F, /) -> _F: ...
-    def get_original_bases(cls: type, /) -> tuple[Any, ...]: ...
-    @final
-    class TypeAliasType:
-        def __init__(
-            self, name: str, value: Any, *, type_params: tuple[TypeVar | ParamSpec | TypeVarTuple, ...] = ()
-        ) -> None: ...
-        @property
-        def __value__(self) -> Any: ...
-        @property
-        def __type_params__(self) -> tuple[TypeVar | ParamSpec | TypeVarTuple, ...]: ...
-        @property
-        def __parameters__(self) -> tuple[Any, ...]: ...
-        @property
-        def __name__(self) -> str: ...
-        # It's writable on types, but not on instances of TypeAliasType.
-        @property
-        def __module__(self) -> str | None: ...  # type: ignore[override]
-        def __getitem__(self, parameters: Any) -> Any: ...
-        if sys.version_info >= (3, 10):
-            def __or__(self, right: Any) -> _SpecialForm: ...
-            def __ror__(self, left: Any) -> _SpecialForm: ...
-
-    @runtime_checkable
-    class Buffer(Protocol):
-        # Not actually a Protocol at runtime; see
-        # https://github.com/python/typeshed/issues/10224 for why we're defining it this way
-        def __buffer__(self, flags: int, /) -> memoryview: ...
-
-if sys.version_info >= (3, 13):
-    from typing import get_protocol_members as get_protocol_members, is_protocol as is_protocol
-else:
-    def is_protocol(tp: type, /) -> bool: ...
-    def get_protocol_members(tp: type, /) -> frozenset[str]: ...
-
-class Doc:
-    documentation: str
-    def __init__(self, documentation: str, /) -> None: ...
-    def __hash__(self) -> int: ...
-    def __eq__(self, other: object) -> bool: ...
-
-ReadOnly: _SpecialForm
-TypeIs: _SpecialForm

jaclang/vendor/mypy/typeshed/stdlib/unicodedata.pyi

@@ -1,73 +0,0 @@
-import sys
-from _typeshed import ReadOnlyBuffer
-from typing import Any, Literal, TypeVar, final, overload
-from typing_extensions import TypeAlias
-
-ucd_3_2_0: UCD
-unidata_version: str
-
-if sys.version_info < (3, 10):
-    ucnhash_CAPI: Any
-
-_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: ...
-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: ...

jaclang/vendor/mypy/typeshed/stdlib/unittest/__init__.pyi

@@ -1,67 +0,0 @@
-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,
-    findTestCases as findTestCases,
-    getTestCaseNames as getTestCaseNames,
-    makeSuite as makeSuite,
-)
-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",
-    "getTestCaseNames",
-    "makeSuite",
-    "findTestCases",
-    "addModuleCleanup",
-]
-
-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]: ...

jaclang/vendor/mypy/typeshed/stdlib/unittest/_log.pyi

@@ -1,27 +0,0 @@
-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
-    if sys.version_info >= (3, 10):
-        def __init__(self, test_case: TestCase, logger_name: str, level: int, no_logs: bool) -> None: ...
-        no_logs: bool
-    else:
-        def __init__(self, test_case: TestCase, logger_name: str, level: int) -> None: ...
-
-    def __enter__(self) -> _L: ...
-    def __exit__(
-        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, tb: TracebackType | None
-    ) -> bool | None: ...

jaclang/vendor/mypy/typeshed/stdlib/unittest/async_case.pyi

@@ -1,21 +0,0 @@
-import sys
-from collections.abc import Awaitable, Callable
-from typing import TypeVar
-from typing_extensions import ParamSpec
-
-from .case import TestCase
-
-if sys.version_info >= (3, 11):
-    from contextlib import AbstractAsyncContextManager
-
-_T = TypeVar("_T")
-_P = ParamSpec("_P")
-
-class IsolatedAsyncioTestCase(TestCase):
-    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: ...
-    if sys.version_info >= (3, 9):
-        def __del__(self) -> None: ...