mypy-dev 1.9.0.dev0__py3-none-any.whl

mypy/typeshed/stdlib/formatter.pyi

@@ -0,0 +1,88 @@
+from collections.abc import Iterable
+from typing import IO, Any
+from typing_extensions import TypeAlias
+
+AS_IS: None
+_FontType: TypeAlias = tuple[str, bool, bool, bool]
+_StylesType: TypeAlias = tuple[Any, ...]
+
+class NullFormatter:
+    writer: NullWriter | None
+    def __init__(self, writer: NullWriter | None = None) -> None: ...
+    def end_paragraph(self, blankline: int) -> None: ...
+    def add_line_break(self) -> None: ...
+    def add_hor_rule(self, *args: Any, **kw: Any) -> None: ...
+    def add_label_data(self, format: str, counter: int, blankline: int | None = None) -> None: ...
+    def add_flowing_data(self, data: str) -> None: ...
+    def add_literal_data(self, data: str) -> None: ...
+    def flush_softspace(self) -> None: ...
+    def push_alignment(self, align: str | None) -> None: ...
+    def pop_alignment(self) -> None: ...
+    def push_font(self, x: _FontType) -> None: ...
+    def pop_font(self) -> None: ...
+    def push_margin(self, margin: int) -> None: ...
+    def pop_margin(self) -> None: ...
+    def set_spacing(self, spacing: str | None) -> None: ...
+    def push_style(self, *styles: _StylesType) -> None: ...
+    def pop_style(self, n: int = 1) -> None: ...
+    def assert_line_data(self, flag: int = 1) -> None: ...
+
+class AbstractFormatter:
+    writer: NullWriter
+    align: str | None
+    align_stack: list[str | None]
+    font_stack: list[_FontType]
+    margin_stack: list[int]
+    spacing: str | None
+    style_stack: Any
+    nospace: int
+    softspace: int
+    para_end: int
+    parskip: int
+    hard_break: int
+    have_label: int
+    def __init__(self, writer: NullWriter) -> None: ...
+    def end_paragraph(self, blankline: int) -> None: ...
+    def add_line_break(self) -> None: ...
+    def add_hor_rule(self, *args: Any, **kw: Any) -> None: ...
+    def add_label_data(self, format: str, counter: int, blankline: int | None = None) -> None: ...
+    def format_counter(self, format: Iterable[str], counter: int) -> str: ...
+    def format_letter(self, case: str, counter: int) -> str: ...
+    def format_roman(self, case: str, counter: int) -> str: ...
+    def add_flowing_data(self, data: str) -> None: ...
+    def add_literal_data(self, data: str) -> None: ...
+    def flush_softspace(self) -> None: ...
+    def push_alignment(self, align: str | None) -> None: ...
+    def pop_alignment(self) -> None: ...
+    def push_font(self, font: _FontType) -> None: ...
+    def pop_font(self) -> None: ...
+    def push_margin(self, margin: int) -> None: ...
+    def pop_margin(self) -> None: ...
+    def set_spacing(self, spacing: str | None) -> None: ...
+    def push_style(self, *styles: _StylesType) -> None: ...
+    def pop_style(self, n: int = 1) -> None: ...
+    def assert_line_data(self, flag: int = 1) -> None: ...
+
+class NullWriter:
+    def flush(self) -> None: ...
+    def new_alignment(self, align: str | None) -> None: ...
+    def new_font(self, font: _FontType) -> None: ...
+    def new_margin(self, margin: int, level: int) -> None: ...
+    def new_spacing(self, spacing: str | None) -> None: ...
+    def new_styles(self, styles: tuple[Any, ...]) -> None: ...
+    def send_paragraph(self, blankline: int) -> None: ...
+    def send_line_break(self) -> None: ...
+    def send_hor_rule(self, *args: Any, **kw: Any) -> None: ...
+    def send_label_data(self, data: str) -> None: ...
+    def send_flowing_data(self, data: str) -> None: ...
+    def send_literal_data(self, data: str) -> None: ...
+
+class AbstractWriter(NullWriter): ...
+
+class DumbWriter(NullWriter):
+    file: IO[str]
+    maxcol: int
+    def __init__(self, file: IO[str] | None = None, maxcol: int = 72) -> None: ...
+    def reset(self) -> None: ...
+
+def test(file: str | None = None) -> None: ...

mypy/typeshed/stdlib/fractions.pyi

@@ -0,0 +1,150 @@
+import sys
+from collections.abc import Callable
+from decimal import Decimal
+from numbers import Integral, Rational, Real
+from typing import Any, Literal, SupportsIndex, overload
+from typing_extensions import Self, TypeAlias
+
+_ComparableNum: TypeAlias = int | float | Decimal | Real
+
+if sys.version_info >= (3, 9):
+    __all__ = ["Fraction"]
+else:
+    __all__ = ["Fraction", "gcd"]
+    @overload
+    def gcd(a: int, b: int) -> int: ...
+    @overload
+    def gcd(a: Integral, b: int) -> Integral: ...
+    @overload
+    def gcd(a: int, b: Integral) -> Integral: ...
+    @overload
+    def gcd(a: Integral, b: Integral) -> Integral: ...
+
+class Fraction(Rational):
+    @overload
+    def __new__(cls, numerator: int | Rational = 0, denominator: int | Rational | None = None) -> Self: ...
+    @overload
+    def __new__(cls, __value: float | Decimal | str) -> Self: ...
+    @classmethod
+    def from_float(cls, f: float) -> Self: ...
+    @classmethod
+    def from_decimal(cls, dec: Decimal) -> Self: ...
+    def limit_denominator(self, max_denominator: int = 1000000) -> Fraction: ...
+    def as_integer_ratio(self) -> tuple[int, int]: ...
+    if sys.version_info >= (3, 12):
+        def is_integer(self) -> bool: ...
+
+    @property
+    def numerator(a) -> int: ...
+    @property
+    def denominator(a) -> int: ...
+    @overload
+    def __add__(a, b: int | Fraction) -> Fraction: ...
+    @overload
+    def __add__(a, b: float) -> float: ...
+    @overload
+    def __add__(a, b: complex) -> complex: ...
+    @overload
+    def __radd__(b, a: int | Fraction) -> Fraction: ...
+    @overload
+    def __radd__(b, a: float) -> float: ...
+    @overload
+    def __radd__(b, a: complex) -> complex: ...
+    @overload
+    def __sub__(a, b: int | Fraction) -> Fraction: ...
+    @overload
+    def __sub__(a, b: float) -> float: ...
+    @overload
+    def __sub__(a, b: complex) -> complex: ...
+    @overload
+    def __rsub__(b, a: int | Fraction) -> Fraction: ...
+    @overload
+    def __rsub__(b, a: float) -> float: ...
+    @overload
+    def __rsub__(b, a: complex) -> complex: ...
+    @overload
+    def __mul__(a, b: int | Fraction) -> Fraction: ...
+    @overload
+    def __mul__(a, b: float) -> float: ...
+    @overload
+    def __mul__(a, b: complex) -> complex: ...
+    @overload
+    def __rmul__(b, a: int | Fraction) -> Fraction: ...
+    @overload
+    def __rmul__(b, a: float) -> float: ...
+    @overload
+    def __rmul__(b, a: complex) -> complex: ...
+    @overload
+    def __truediv__(a, b: int | Fraction) -> Fraction: ...
+    @overload
+    def __truediv__(a, b: float) -> float: ...
+    @overload
+    def __truediv__(a, b: complex) -> complex: ...
+    @overload
+    def __rtruediv__(b, a: int | Fraction) -> Fraction: ...
+    @overload
+    def __rtruediv__(b, a: float) -> float: ...
+    @overload
+    def __rtruediv__(b, a: complex) -> complex: ...
+    @overload
+    def __floordiv__(a, b: int | Fraction) -> int: ...
+    @overload
+    def __floordiv__(a, b: float) -> float: ...
+    @overload
+    def __rfloordiv__(b, a: int | Fraction) -> int: ...
+    @overload
+    def __rfloordiv__(b, a: float) -> float: ...
+    @overload
+    def __mod__(a, b: int | Fraction) -> Fraction: ...
+    @overload
+    def __mod__(a, b: float) -> float: ...
+    @overload
+    def __rmod__(b, a: int | Fraction) -> Fraction: ...
+    @overload
+    def __rmod__(b, a: float) -> float: ...
+    @overload
+    def __divmod__(a, b: int | Fraction) -> tuple[int, Fraction]: ...
+    @overload
+    def __divmod__(a, b: float) -> tuple[float, Fraction]: ...
+    @overload
+    def __rdivmod__(a, b: int | Fraction) -> tuple[int, Fraction]: ...
+    @overload
+    def __rdivmod__(a, b: float) -> tuple[float, Fraction]: ...
+    @overload
+    def __pow__(a, b: int) -> Fraction: ...
+    @overload
+    def __pow__(a, b: float | Fraction) -> float: ...
+    @overload
+    def __pow__(a, b: complex) -> complex: ...
+    @overload
+    def __rpow__(b, a: float | Fraction) -> float: ...
+    @overload
+    def __rpow__(b, a: complex) -> complex: ...
+    def __pos__(a) -> Fraction: ...
+    def __neg__(a) -> Fraction: ...
+    def __abs__(a) -> Fraction: ...
+    def __trunc__(a) -> int: ...
+    def __floor__(a) -> int: ...
+    def __ceil__(a) -> int: ...
+    @overload
+    def __round__(self, ndigits: None = None) -> int: ...
+    @overload
+    def __round__(self, ndigits: int) -> Fraction: ...
+    def __hash__(self) -> int: ...
+    def __eq__(a, b: object) -> bool: ...
+    def __lt__(a, b: _ComparableNum) -> bool: ...
+    def __gt__(a, b: _ComparableNum) -> bool: ...
+    def __le__(a, b: _ComparableNum) -> bool: ...
+    def __ge__(a, b: _ComparableNum) -> bool: ...
+    def __bool__(a) -> bool: ...
+    def __copy__(self) -> Self: ...
+    def __deepcopy__(self, memo: Any) -> Self: ...
+    if sys.version_info >= (3, 11):
+        def __int__(a, _index: Callable[[SupportsIndex], int] = ...) -> int: ...
+    # Not actually defined within fractions.py, but provides more useful
+    # overrides
+    @property
+    def real(self) -> Fraction: ...
+    @property
+    def imag(self) -> Literal[0]: ...
+    def conjugate(self) -> Fraction: ...

mypy/typeshed/stdlib/ftplib.pyi

@@ -0,0 +1,178 @@
+import sys
+from _typeshed import SupportsRead, SupportsReadline
+from collections.abc import Callable, Iterable, Iterator
+from socket import socket
+from ssl import SSLContext
+from types import TracebackType
+from typing import Any, Literal, TextIO
+from typing_extensions import Self
+
+__all__ = ["FTP", "error_reply", "error_temp", "error_perm", "error_proto", "all_errors", "FTP_TLS"]
+
+MSG_OOB: Literal[1]
+FTP_PORT: Literal[21]
+MAXLINE: Literal[8192]
+CRLF: Literal["\r\n"]
+B_CRLF: Literal[b"\r\n"]
+
+class Error(Exception): ...
+class error_reply(Error): ...
+class error_temp(Error): ...
+class error_perm(Error): ...
+class error_proto(Error): ...
+
+all_errors: tuple[type[Exception], ...]
+
+class FTP:
+    debugging: int
+    host: str
+    port: int
+    maxline: int
+    sock: socket | None
+    welcome: str | None
+    passiveserver: int
+    timeout: int
+    af: int
+    lastresp: str
+    file: TextIO | None
+    encoding: str
+    def __enter__(self) -> Self: ...
+    def __exit__(
+        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
+    ) -> None: ...
+    source_address: tuple[str, int] | None
+    if sys.version_info >= (3, 9):
+        def __init__(
+            self,
+            host: str = "",
+            user: str = "",
+            passwd: str = "",
+            acct: str = "",
+            timeout: float = ...,
+            source_address: tuple[str, int] | None = None,
+            *,
+            encoding: str = "utf-8",
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            host: str = "",
+            user: str = "",
+            passwd: str = "",
+            acct: str = "",
+            timeout: float = ...,
+            source_address: tuple[str, int] | None = None,
+        ) -> None: ...
+
+    def connect(
+        self, host: str = "", port: int = 0, timeout: float = -999, source_address: tuple[str, int] | None = None
+    ) -> str: ...
+    def getwelcome(self) -> str: ...
+    def set_debuglevel(self, level: int) -> None: ...
+    def debug(self, level: int) -> None: ...
+    def set_pasv(self, val: bool | Literal[0, 1]) -> None: ...
+    def sanitize(self, s: str) -> str: ...
+    def putline(self, line: str) -> None: ...
+    def putcmd(self, line: str) -> None: ...
+    def getline(self) -> str: ...
+    def getmultiline(self) -> str: ...
+    def getresp(self) -> str: ...
+    def voidresp(self) -> str: ...
+    def abort(self) -> str: ...
+    def sendcmd(self, cmd: str) -> str: ...
+    def voidcmd(self, cmd: str) -> str: ...
+    def sendport(self, host: str, port: int) -> str: ...
+    def sendeprt(self, host: str, port: int) -> str: ...
+    def makeport(self) -> socket: ...
+    def makepasv(self) -> tuple[str, int]: ...
+    def login(self, user: str = "", passwd: str = "", acct: str = "") -> str: ...
+    # In practice, `rest` rest can actually be anything whose str() is an integer sequence, so to make it simple we allow integers.
+    def ntransfercmd(self, cmd: str, rest: int | str | None = None) -> tuple[socket, int | None]: ...
+    def transfercmd(self, cmd: str, rest: int | str | None = None) -> socket: ...
+    def retrbinary(
+        self, cmd: str, callback: Callable[[bytes], object], blocksize: int = 8192, rest: int | str | None = None
+    ) -> str: ...
+    def storbinary(
+        self,
+        cmd: str,
+        fp: SupportsRead[bytes],
+        blocksize: int = 8192,
+        callback: Callable[[bytes], object] | None = None,
+        rest: int | str | None = None,
+    ) -> str: ...
+    def retrlines(self, cmd: str, callback: Callable[[str], object] | None = None) -> str: ...
+    def storlines(self, cmd: str, fp: SupportsReadline[bytes], callback: Callable[[bytes], object] | None = None) -> str: ...
+    def acct(self, password: str) -> str: ...
+    def nlst(self, *args: str) -> list[str]: ...
+    # Technically only the last arg can be a Callable but ...
+    def dir(self, *args: str | Callable[[str], object]) -> None: ...
+    def mlsd(self, path: str = "", facts: Iterable[str] = []) -> Iterator[tuple[str, dict[str, str]]]: ...
+    def rename(self, fromname: str, toname: str) -> str: ...
+    def delete(self, filename: str) -> str: ...
+    def cwd(self, dirname: str) -> str: ...
+    def size(self, filename: str) -> int | None: ...
+    def mkd(self, dirname: str) -> str: ...
+    def rmd(self, dirname: str) -> str: ...
+    def pwd(self) -> str: ...
+    def quit(self) -> str: ...
+    def close(self) -> None: ...
+
+class FTP_TLS(FTP):
+    if sys.version_info >= (3, 12):
+        def __init__(
+            self,
+            host: str = "",
+            user: str = "",
+            passwd: str = "",
+            acct: str = "",
+            *,
+            context: SSLContext | None = None,
+            timeout: float = ...,
+            source_address: tuple[str, int] | None = None,
+            encoding: str = "utf-8",
+        ) -> None: ...
+    elif sys.version_info >= (3, 9):
+        def __init__(
+            self,
+            host: str = "",
+            user: str = "",
+            passwd: str = "",
+            acct: str = "",
+            keyfile: str | None = None,
+            certfile: str | None = None,
+            context: SSLContext | None = None,
+            timeout: float = ...,
+            source_address: tuple[str, int] | None = None,
+            *,
+            encoding: str = "utf-8",
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            host: str = "",
+            user: str = "",
+            passwd: str = "",
+            acct: str = "",
+            keyfile: str | None = None,
+            certfile: str | None = None,
+            context: SSLContext | None = None,
+            timeout: float = ...,
+            source_address: tuple[str, int] | None = None,
+        ) -> None: ...
+    ssl_version: int
+    keyfile: str | None
+    certfile: str | None
+    context: SSLContext
+    def login(self, user: str = "", passwd: str = "", acct: str = "", secure: bool = True) -> str: ...
+    def auth(self) -> str: ...
+    def prot_p(self) -> str: ...
+    def prot_c(self) -> str: ...
+    def ccc(self) -> str: ...
+
+def parse150(resp: str) -> int | None: ...  # undocumented
+def parse227(resp: str) -> tuple[str, int]: ...  # undocumented
+def parse229(resp: str, peer: Any) -> tuple[str, int]: ...  # undocumented
+def parse257(resp: str) -> str: ...  # undocumented
+def ftpcp(
+    source: FTP, sourcename: str, target: FTP, targetname: str = "", type: Literal["A", "I"] = "I"
+) -> None: ...  # undocumented

mypy/typeshed/stdlib/functools.pyi

@@ -0,0 +1,200 @@
+import sys
+import types
+from _typeshed import IdentityFunction, SupportsAllComparisons, SupportsItems
+from collections.abc import Callable, Hashable, Iterable, Sequence, Sized
+from typing import Any, Generic, Literal, NamedTuple, TypedDict, TypeVar, final, overload
+from typing_extensions import Self, TypeAlias
+
+if sys.version_info >= (3, 9):
+    from types import GenericAlias
+
+__all__ = [
+    "update_wrapper",
+    "wraps",
+    "WRAPPER_ASSIGNMENTS",
+    "WRAPPER_UPDATES",
+    "total_ordering",
+    "cmp_to_key",
+    "lru_cache",
+    "reduce",
+    "partial",
+    "partialmethod",
+    "singledispatch",
+    "cached_property",
+    "singledispatchmethod",
+]
+
+if sys.version_info >= (3, 9):
+    __all__ += ["cache"]
+
+_AnyCallable: TypeAlias = Callable[..., object]
+
+_T = TypeVar("_T")
+_S = TypeVar("_S")
+
+@overload
+def reduce(__function: Callable[[_T, _S], _T], __sequence: Iterable[_S], __initial: _T) -> _T: ...
+@overload
+def reduce(__function: Callable[[_T, _T], _T], __sequence: Iterable[_T]) -> _T: ...
+
+class _CacheInfo(NamedTuple):
+    hits: int
+    misses: int
+    maxsize: int | None
+    currsize: int
+
+if sys.version_info >= (3, 9):
+    class _CacheParameters(TypedDict):
+        maxsize: int
+        typed: bool
+
+@final
+class _lru_cache_wrapper(Generic[_T]):
+    __wrapped__: Callable[..., _T]
+    def __call__(self, *args: Hashable, **kwargs: Hashable) -> _T: ...
+    def cache_info(self) -> _CacheInfo: ...
+    def cache_clear(self) -> None: ...
+    if sys.version_info >= (3, 9):
+        def cache_parameters(self) -> _CacheParameters: ...
+
+    def __copy__(self) -> _lru_cache_wrapper[_T]: ...
+    def __deepcopy__(self, __memo: Any) -> _lru_cache_wrapper[_T]: ...
+
+@overload
+def lru_cache(maxsize: int | None = 128, typed: bool = False) -> Callable[[Callable[..., _T]], _lru_cache_wrapper[_T]]: ...
+@overload
+def lru_cache(maxsize: Callable[..., _T], typed: bool = False) -> _lru_cache_wrapper[_T]: ...
+
+if sys.version_info >= (3, 12):
+    WRAPPER_ASSIGNMENTS: tuple[
+        Literal["__module__"],
+        Literal["__name__"],
+        Literal["__qualname__"],
+        Literal["__doc__"],
+        Literal["__annotations__"],
+        Literal["__type_params__"],
+    ]
+else:
+    WRAPPER_ASSIGNMENTS: tuple[
+        Literal["__module__"], Literal["__name__"], Literal["__qualname__"], Literal["__doc__"], Literal["__annotations__"]
+    ]
+WRAPPER_UPDATES: tuple[Literal["__dict__"]]
+
+if sys.version_info >= (3, 12):
+    def update_wrapper(
+        wrapper: _T,
+        wrapped: _AnyCallable,
+        assigned: Sequence[str] = ("__module__", "__name__", "__qualname__", "__doc__", "__annotations__", "__type_params__"),
+        updated: Sequence[str] = ("__dict__",),
+    ) -> _T: ...
+    def wraps(
+        wrapped: _AnyCallable,
+        assigned: Sequence[str] = ("__module__", "__name__", "__qualname__", "__doc__", "__annotations__", "__type_params__"),
+        updated: Sequence[str] = ("__dict__",),
+    ) -> IdentityFunction: ...
+
+else:
+    def update_wrapper(
+        wrapper: _T,
+        wrapped: _AnyCallable,
+        assigned: Sequence[str] = ("__module__", "__name__", "__qualname__", "__doc__", "__annotations__"),
+        updated: Sequence[str] = ("__dict__",),
+    ) -> _T: ...
+    def wraps(
+        wrapped: _AnyCallable,
+        assigned: Sequence[str] = ("__module__", "__name__", "__qualname__", "__doc__", "__annotations__"),
+        updated: Sequence[str] = ("__dict__",),
+    ) -> IdentityFunction: ...
+
+def total_ordering(cls: type[_T]) -> type[_T]: ...
+def cmp_to_key(mycmp: Callable[[_T, _T], int]) -> Callable[[_T], SupportsAllComparisons]: ...
+
+class partial(Generic[_T]):
+    @property
+    def func(self) -> Callable[..., _T]: ...
+    @property
+    def args(self) -> tuple[Any, ...]: ...
+    @property
+    def keywords(self) -> dict[str, Any]: ...
+    def __new__(cls, __func: Callable[..., _T], *args: Any, **kwargs: Any) -> Self: ...
+    def __call__(__self, *args: Any, **kwargs: Any) -> _T: ...
+    if sys.version_info >= (3, 9):
+        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+
+# With protocols, this could change into a generic protocol that defines __get__ and returns _T
+_Descriptor: TypeAlias = Any
+
+class partialmethod(Generic[_T]):
+    func: Callable[..., _T] | _Descriptor
+    args: tuple[Any, ...]
+    keywords: dict[str, Any]
+    @overload
+    def __init__(self, __func: Callable[..., _T], *args: Any, **keywords: Any) -> None: ...
+    @overload
+    def __init__(self, __func: _Descriptor, *args: Any, **keywords: Any) -> None: ...
+    def __get__(self, obj: Any, cls: type[Any] | None = None) -> Callable[..., _T]: ...
+    @property
+    def __isabstractmethod__(self) -> bool: ...
+    if sys.version_info >= (3, 9):
+        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+
+class _SingleDispatchCallable(Generic[_T]):
+    registry: types.MappingProxyType[Any, Callable[..., _T]]
+    def dispatch(self, cls: Any) -> Callable[..., _T]: ...
+    # @fun.register(complex)
+    # def _(arg, verbose=False): ...
+    @overload
+    def register(self, cls: type[Any], func: None = None) -> Callable[[Callable[..., _T]], Callable[..., _T]]: ...
+    # @fun.register
+    # def _(arg: int, verbose=False):
+    @overload
+    def register(self, cls: Callable[..., _T], func: None = None) -> Callable[..., _T]: ...
+    # fun.register(int, lambda x: x)
+    @overload
+    def register(self, cls: type[Any], func: Callable[..., _T]) -> Callable[..., _T]: ...
+    def _clear_cache(self) -> None: ...
+    def __call__(__self, *args: Any, **kwargs: Any) -> _T: ...
+
+def singledispatch(func: Callable[..., _T]) -> _SingleDispatchCallable[_T]: ...
+
+class singledispatchmethod(Generic[_T]):
+    dispatcher: _SingleDispatchCallable[_T]
+    func: Callable[..., _T]
+    def __init__(self, func: Callable[..., _T]) -> None: ...
+    @property
+    def __isabstractmethod__(self) -> bool: ...
+    @overload
+    def register(self, cls: type[Any], method: None = None) -> Callable[[Callable[..., _T]], Callable[..., _T]]: ...
+    @overload
+    def register(self, cls: Callable[..., _T], method: None = None) -> Callable[..., _T]: ...
+    @overload
+    def register(self, cls: type[Any], method: Callable[..., _T]) -> Callable[..., _T]: ...
+    def __get__(self, obj: _S, cls: type[_S] | None = None) -> Callable[..., _T]: ...
+
+class cached_property(Generic[_T]):
+    func: Callable[[Any], _T]
+    attrname: str | None
+    def __init__(self, func: Callable[[Any], _T]) -> None: ...
+    @overload
+    def __get__(self, instance: None, owner: type[Any] | None = None) -> Self: ...
+    @overload
+    def __get__(self, instance: object, owner: type[Any] | None = None) -> _T: ...
+    def __set_name__(self, owner: type[Any], name: str) -> None: ...
+    # __set__ is not defined at runtime, but @cached_property is designed to be settable
+    def __set__(self, instance: object, value: _T) -> None: ...
+    if sys.version_info >= (3, 9):
+        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+
+if sys.version_info >= (3, 9):
+    def cache(__user_function: Callable[..., _T]) -> _lru_cache_wrapper[_T]: ...
+
+def _make_key(
+    args: tuple[Hashable, ...],
+    kwds: SupportsItems[Any, Any],
+    typed: bool,
+    kwd_mark: tuple[object, ...] = ...,
+    fasttypes: set[type] = ...,
+    tuple: type = ...,
+    type: Any = ...,
+    len: Callable[[Sized], int] = ...,
+) -> Hashable: ...

mypy/typeshed/stdlib/gc.pyi

@@ -0,0 +1,37 @@
+import sys
+from collections.abc import Callable
+from typing import Any, Literal
+from typing_extensions import TypeAlias
+
+DEBUG_COLLECTABLE: Literal[2]
+DEBUG_LEAK: Literal[38]
+DEBUG_SAVEALL: Literal[32]
+DEBUG_STATS: Literal[1]
+DEBUG_UNCOLLECTABLE: Literal[4]
+
+_CallbackType: TypeAlias = Callable[[Literal["start", "stop"], dict[str, int]], object]
+
+callbacks: list[_CallbackType]
+garbage: list[Any]
+
+def collect(generation: int = 2) -> int: ...
+def disable() -> None: ...
+def enable() -> None: ...
+def get_count() -> tuple[int, int, int]: ...
+def get_debug() -> int: ...
+def get_objects(generation: int | None = None) -> list[Any]: ...
+def freeze() -> None: ...
+def unfreeze() -> None: ...
+def get_freeze_count() -> int: ...
+def get_referents(*objs: Any) -> list[Any]: ...
+def get_referrers(*objs: Any) -> list[Any]: ...
+def get_stats() -> list[dict[str, Any]]: ...
+def get_threshold() -> tuple[int, int, int]: ...
+def is_tracked(__obj: Any) -> bool: ...
+
+if sys.version_info >= (3, 9):
+    def is_finalized(__obj: Any) -> bool: ...
+
+def isenabled() -> bool: ...
+def set_debug(__flags: int) -> None: ...
+def set_threshold(threshold0: int, threshold1: int = ..., threshold2: int = ...) -> None: ...