Drop Python 3.8 branches (#13776)

stdlib/@tests/test_cases/check_importlib.py

@@ -10,14 +10,14 @@ from importlib.machinery import ModuleSpec
 from types import ModuleType
 from typing_extensions import Self
 
+
 # Assert that some Path classes are Traversable.
-if sys.version_info >= (3, 9):
+def traverse(t: importlib.abc.Traversable) -> None:
+    pass
 
-    def traverse(t: importlib.abc.Traversable) -> None:
-        pass
 
-    traverse(pathlib.Path())
-    traverse(zipfile.Path(""))
+traverse(pathlib.Path())
+traverse(zipfile.Path(""))
 
 
 class MetaFinder:

stdlib/@tests/test_cases/check_platform.py

@@ -1,16 +1,12 @@
 from __future__ import annotations
 
 import platform
-import sys
 from typing_extensions import assert_type
 
 # platform.uname_result emulates a 6 field named tuple, but on 3.9+ the processor
 # field is lazily evaluated, which results in it being a little funky.
 uname = platform.uname()
-if sys.version_info >= (3, 9):
-    myuname = platform.uname_result("Darwin", "local", "22.5.0", "Darwin Kernel Version 22.5.0", "arm64")
-else:
-    myuname = platform.uname_result("Darwin", "local", "22.5.0", "Darwin Kernel Version 22.5.0", "arm64", "arm")
+myuname = platform.uname_result("Darwin", "local", "22.5.0", "Darwin Kernel Version 22.5.0", "arm64")
 
 assert_type(uname, platform.uname_result)
 assert_type(myuname, platform.uname_result)

stdlib/@tests/test_cases/check_xml.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import sys
 from typing_extensions import assert_type
 from xml.dom.minidom import Document
 
@@ -10,10 +9,9 @@ assert_type(document.toxml(), str)
 assert_type(document.toxml(encoding=None), str)
 assert_type(document.toxml(encoding="UTF8"), bytes)
 assert_type(document.toxml("UTF8"), bytes)
-if sys.version_info >= (3, 9):
-    assert_type(document.toxml(standalone=True), str)
-    assert_type(document.toxml("UTF8", True), bytes)
-    assert_type(document.toxml(encoding="UTF8", standalone=True), bytes)
+assert_type(document.toxml(standalone=True), str)
+assert_type(document.toxml("UTF8", True), bytes)
+assert_type(document.toxml(encoding="UTF8", standalone=True), bytes)
 
 
 # Because toprettyxml can mix positional and keyword variants of the "encoding" argument, which
@@ -23,13 +21,11 @@ if sys.version_info >= (3, 9):
 assert_type(document.toprettyxml(), str)
 assert_type(document.toprettyxml(encoding=None), str)
 assert_type(document.toprettyxml(encoding="UTF8"), bytes)
-if sys.version_info >= (3, 9):
-    assert_type(document.toprettyxml(standalone=True), str)
-    assert_type(document.toprettyxml(encoding="UTF8", standalone=True), bytes)
+assert_type(document.toprettyxml(standalone=True), str)
+assert_type(document.toprettyxml(encoding="UTF8", standalone=True), bytes)
 # Test cases unique to toprettyxml
 assert_type(document.toprettyxml("  "), str)
 assert_type(document.toprettyxml("  ", "\r\n"), str)
 assert_type(document.toprettyxml("  ", "\r\n", "UTF8"), bytes)
-if sys.version_info >= (3, 9):
-    assert_type(document.toprettyxml("  ", "\r\n", "UTF8", True), bytes)
-    assert_type(document.toprettyxml("  ", "\r\n", standalone=True), str)
+assert_type(document.toprettyxml("  ", "\r\n", "UTF8", True), bytes)
+assert_type(document.toprettyxml("  ", "\r\n", standalone=True), str)

stdlib/@tests/test_cases/collections/check_defaultdict-py39.py

@@ -1,72 +0,0 @@
-"""
-Tests for `defaultdict.__or__` and `defaultdict.__ror__`.
-These methods were only added in py39.
-"""
-
-from __future__ import annotations
-
-import os
-import sys
-from collections import defaultdict
-from typing import Mapping, TypeVar, Union
-from typing_extensions import Self, assert_type
-
-_KT = TypeVar("_KT")
-_VT = TypeVar("_VT")
-
-
-if sys.version_info >= (3, 9):
-
-    class CustomDefaultDictSubclass(defaultdict[_KT, _VT]):
-        pass
-
-    class CustomMappingWithDunderOr(Mapping[_KT, _VT]):
-        def __or__(self, other: Mapping[_KT, _VT]) -> dict[_KT, _VT]:
-            return {}
-
-        def __ror__(self, other: Mapping[_KT, _VT]) -> dict[_KT, _VT]:
-            return {}
-
-        def __ior__(self, other: Mapping[_KT, _VT]) -> Self:
-            return self
-
-    def test_defaultdict_dot_or(
-        a: defaultdict[int, int],
-        b: CustomDefaultDictSubclass[int, int],
-        c: defaultdict[str, str],
-        d: Mapping[int, int],
-        e: CustomMappingWithDunderOr[str, str],
-    ) -> None:
-        assert_type(a | b, defaultdict[int, int])
-
-        # In contrast to `dict.__or__`, `defaultdict.__or__` returns `Self` if called on a subclass of `defaultdict`:
-        assert_type(b | a, CustomDefaultDictSubclass[int, int])
-
-        assert_type(a | c, defaultdict[Union[int, str], Union[int, str]])
-
-        # arbitrary mappings are not accepted by `defaultdict.__or__`;
-        # it has to be a subclass of `dict`
-        a | d  # type: ignore
-
-        # but Mappings such as `os._Environ` or `CustomMappingWithDunderOr`,
-        # which define `__ror__` methods that accept `dict`, are fine
-        # (`os._Environ.__(r)or__` always returns `dict`, even if a `defaultdict` is passed):
-        assert_type(a | os.environ, dict[Union[str, int], Union[str, int]])
-        assert_type(os.environ | a, dict[Union[str, int], Union[str, int]])
-
-        assert_type(c | os.environ, dict[str, str])
-        assert_type(c | e, dict[str, str])
-
-        assert_type(os.environ | c, dict[str, str])
-        assert_type(e | c, dict[str, str])
-
-        # store "untainted" `CustomMappingWithDunderOr[str, str]` to test `__ior__` against ` defaultdict[str, str]` later
-        # Invalid `e |= a` causes pyright to join `Unknown` to `e`'s type
-        f = e
-
-        e |= c
-        e |= a  # type: ignore
-
-        c |= f
-
-        c |= a  # type: ignore

stdlib/@tests/test_cases/collections/check_defaultdict.py

@@ -0,0 +1,70 @@
+"""
+Tests for `defaultdict.__or__` and `defaultdict.__ror__`.
+"""
+
+from __future__ import annotations
+
+import os
+from collections import defaultdict
+from typing import Mapping, TypeVar, Union
+from typing_extensions import Self, assert_type
+
+_KT = TypeVar("_KT")
+_VT = TypeVar("_VT")
+
+
+class CustomDefaultDictSubclass(defaultdict[_KT, _VT]):
+    pass
+
+
+class CustomMappingWithDunderOr(Mapping[_KT, _VT]):
+    def __or__(self, other: Mapping[_KT, _VT]) -> dict[_KT, _VT]:
+        return {}
+
+    def __ror__(self, other: Mapping[_KT, _VT]) -> dict[_KT, _VT]:
+        return {}
+
+    def __ior__(self, other: Mapping[_KT, _VT]) -> Self:
+        return self
+
+
+def test_defaultdict_dot_or(
+    a: defaultdict[int, int],
+    b: CustomDefaultDictSubclass[int, int],
+    c: defaultdict[str, str],
+    d: Mapping[int, int],
+    e: CustomMappingWithDunderOr[str, str],
+) -> None:
+    assert_type(a | b, defaultdict[int, int])
+
+    # In contrast to `dict.__or__`, `defaultdict.__or__` returns `Self` if called on a subclass of `defaultdict`:
+    assert_type(b | a, CustomDefaultDictSubclass[int, int])
+
+    assert_type(a | c, defaultdict[Union[int, str], Union[int, str]])
+
+    # arbitrary mappings are not accepted by `defaultdict.__or__`;
+    # it has to be a subclass of `dict`
+    a | d  # type: ignore
+
+    # but Mappings such as `os._Environ` or `CustomMappingWithDunderOr`,
+    # which define `__ror__` methods that accept `dict`, are fine
+    # (`os._Environ.__(r)or__` always returns `dict`, even if a `defaultdict` is passed):
+    assert_type(a | os.environ, dict[Union[str, int], Union[str, int]])
+    assert_type(os.environ | a, dict[Union[str, int], Union[str, int]])
+
+    assert_type(c | os.environ, dict[str, str])
+    assert_type(c | e, dict[str, str])
+
+    assert_type(os.environ | c, dict[str, str])
+    assert_type(e | c, dict[str, str])
+
+    # store "untainted" `CustomMappingWithDunderOr[str, str]` to test `__ior__` against ` defaultdict[str, str]` later
+    # Invalid `e |= a` causes pyright to join `Unknown` to `e`'s type
+    f = e
+
+    e |= c
+    e |= a  # type: ignore
+
+    c |= f
+
+    c |= a  # type: ignore

stdlib/_ctypes.pyi

@@ -4,12 +4,10 @@ from _typeshed import ReadableBuffer, StrOrBytesPath, WriteableBuffer
 from abc import abstractmethod
 from collections.abc import Callable, Iterable, Iterator, Mapping, Sequence
 from ctypes import CDLL, ArgumentError as ArgumentError, c_void_p
+from types import GenericAlias
 from typing import Any, ClassVar, Generic, TypeVar, final, overload, type_check_only
 from typing_extensions import Self, TypeAlias
 
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
-
 _T = TypeVar("_T")
 _CT = TypeVar("_CT", bound=_CData)
 
@@ -317,8 +315,7 @@ class Array(_CData, Generic[_CT], metaclass=_PyCArrayType):
     # Can't inherit from Sized because the metaclass conflict between
     # Sized and _CData prevents using _CDataMeta.
     def __len__(self) -> int: ...
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 def addressof(obj: _CData | _CDataType, /) -> int: ...
 def alignment(obj_or_type: _CData | _CDataType | type[_CData | _CDataType], /) -> int: ...

stdlib/_curses.pyi

@@ -292,11 +292,8 @@ def erasechar() -> bytes: ...
 def filter() -> None: ...
 def flash() -> None: ...
 def flushinp() -> None: ...
-
-if sys.version_info >= (3, 9):
-    def get_escdelay() -> int: ...
-    def get_tabsize() -> int: ...
-
+def get_escdelay() -> int: ...
+def get_tabsize() -> int: ...
 def getmouse() -> tuple[int, int, int, int, int]: ...
 def getsyx() -> tuple[int, int]: ...
 def getwin(file: SupportsRead[bytes], /) -> window: ...
@@ -341,11 +338,8 @@ def resetty() -> None: ...
 def resize_term(nlines: int, ncols: int, /) -> None: ...
 def resizeterm(nlines: int, ncols: int, /) -> None: ...
 def savetty() -> None: ...
-
-if sys.version_info >= (3, 9):
-    def set_escdelay(ms: int, /) -> None: ...
-    def set_tabsize(size: int, /) -> None: ...
-
+def set_escdelay(ms: int, /) -> None: ...
+def set_tabsize(size: int, /) -> None: ...
 def setsyx(y: int, x: int, /) -> None: ...
 def setupterm(term: str | None = None, fd: int = -1) -> None: ...
 def start_color() -> None: ...

stdlib/_hashlib.pyi

@@ -37,53 +37,42 @@ class HASH:
 if sys.version_info >= (3, 10):
     class UnsupportedDigestmodError(ValueError): ...
 
-if sys.version_info >= (3, 9):
-    class HASHXOF(HASH):
-        def digest(self, length: int) -> bytes: ...  # type: ignore[override]
-        def hexdigest(self, length: int) -> str: ...  # type: ignore[override]
+class HASHXOF(HASH):
+    def digest(self, length: int) -> bytes: ...  # type: ignore[override]
+    def hexdigest(self, length: int) -> str: ...  # type: ignore[override]
 
-    @final
-    class HMAC:
-        @property
-        def digest_size(self) -> int: ...
-        @property
-        def block_size(self) -> int: ...
-        @property
-        def name(self) -> str: ...
-        def copy(self) -> Self: ...
-        def digest(self) -> bytes: ...
-        def hexdigest(self) -> str: ...
-        def update(self, msg: ReadableBuffer) -> None: ...
-
-    @overload
-    def compare_digest(a: ReadableBuffer, b: ReadableBuffer, /) -> bool: ...
-    @overload
-    def compare_digest(a: AnyStr, b: AnyStr, /) -> bool: ...
-    def get_fips_mode() -> int: ...
-    def hmac_new(key: bytes | bytearray, msg: ReadableBuffer = b"", digestmod: _DigestMod = None) -> HMAC: ...
-    def new(name: str, string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
-    def openssl_md5(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
-    def openssl_sha1(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
-    def openssl_sha224(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
-    def openssl_sha256(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
-    def openssl_sha384(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
-    def openssl_sha512(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
-    def openssl_sha3_224(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
-    def openssl_sha3_256(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
-    def openssl_sha3_384(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
-    def openssl_sha3_512(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
-    def openssl_shake_128(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASHXOF: ...
-    def openssl_shake_256(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASHXOF: ...
-
-else:
-    def new(name: str, string: ReadableBuffer = b"") -> HASH: ...
-    def openssl_md5(string: ReadableBuffer = b"") -> HASH: ...
-    def openssl_sha1(string: ReadableBuffer = b"") -> HASH: ...
-    def openssl_sha224(string: ReadableBuffer = b"") -> HASH: ...
-    def openssl_sha256(string: ReadableBuffer = b"") -> HASH: ...
-    def openssl_sha384(string: ReadableBuffer = b"") -> HASH: ...
-    def openssl_sha512(string: ReadableBuffer = b"") -> HASH: ...
+@final
+class HMAC:
+    @property
+    def digest_size(self) -> int: ...
+    @property
+    def block_size(self) -> int: ...
+    @property
+    def name(self) -> str: ...
+    def copy(self) -> Self: ...
+    def digest(self) -> bytes: ...
+    def hexdigest(self) -> str: ...
+    def update(self, msg: ReadableBuffer) -> None: ...
 
+@overload
+def compare_digest(a: ReadableBuffer, b: ReadableBuffer, /) -> bool: ...
+@overload
+def compare_digest(a: AnyStr, b: AnyStr, /) -> bool: ...
+def get_fips_mode() -> int: ...
+def hmac_new(key: bytes | bytearray, msg: ReadableBuffer = b"", digestmod: _DigestMod = None) -> HMAC: ...
+def new(name: str, string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
+def openssl_md5(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
+def openssl_sha1(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
+def openssl_sha224(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
+def openssl_sha256(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
+def openssl_sha384(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
+def openssl_sha512(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
+def openssl_sha3_224(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
+def openssl_sha3_256(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
+def openssl_sha3_384(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
+def openssl_sha3_512(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASH: ...
+def openssl_shake_128(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASHXOF: ...
+def openssl_shake_256(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> HASHXOF: ...
 def hmac_digest(key: bytes | bytearray, msg: ReadableBuffer, digest: str) -> bytes: ...
 def pbkdf2_hmac(
     hash_name: str, password: ReadableBuffer, salt: ReadableBuffer, iterations: int, dklen: int | None = None

stdlib/_queue.pyi

@@ -1,9 +1,6 @@
-import sys
+from types import GenericAlias
 from typing import Any, Generic, TypeVar
 
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
-
 _T = TypeVar("_T")
 
 class Empty(Exception): ...
@@ -16,5 +13,4 @@ class SimpleQueue(Generic[_T]):
     def put(self, item: _T, block: bool = True, timeout: float | None = None) -> None: ...
     def put_nowait(self, item: _T) -> None: ...
     def qsize(self) -> int: ...
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...

stdlib/_socket.pyi

@@ -192,7 +192,7 @@ if sys.platform != "win32" and sys.platform != "darwin" and sys.platform != "lin
     IPPROTO_BIP: int  # Not FreeBSD either
     IPPROTO_MOBILE: int  # Not FreeBSD either
     IPPROTO_VRRP: int  # Not FreeBSD either
-if sys.version_info >= (3, 9) and sys.platform == "linux":
+if sys.platform == "linux":
     # Availability: Linux >= 2.6.20, FreeBSD >= 10.1
     IPPROTO_UDPLITE: int
 if sys.version_info >= (3, 10) and sys.platform == "linux":
@@ -250,29 +250,26 @@ IPV6_RECVTCLASS: int
 IPV6_TCLASS: int
 IPV6_UNICAST_HOPS: int
 IPV6_V6ONLY: int
-if sys.version_info >= (3, 9) or sys.platform != "darwin":
-    IPV6_DONTFRAG: int
-    IPV6_HOPLIMIT: int
-    IPV6_HOPOPTS: int
-    IPV6_PKTINFO: int
-    IPV6_RECVRTHDR: int
-    IPV6_RTHDR: int
+IPV6_DONTFRAG: int
+IPV6_HOPLIMIT: int
+IPV6_HOPOPTS: int
+IPV6_PKTINFO: int
+IPV6_RECVRTHDR: int
+IPV6_RTHDR: int
 if sys.platform != "win32":
     IPV6_RTHDR_TYPE_0: int
-    if sys.version_info >= (3, 9) or sys.platform != "darwin":
-        IPV6_DSTOPTS: int
-        IPV6_NEXTHOP: int
-        IPV6_PATHMTU: int
-        IPV6_RECVDSTOPTS: int
-        IPV6_RECVHOPLIMIT: int
-        IPV6_RECVHOPOPTS: int
-        IPV6_RECVPATHMTU: int
-        IPV6_RECVPKTINFO: int
-        IPV6_RTHDRDSTOPTS: int
+    IPV6_DSTOPTS: int
+    IPV6_NEXTHOP: int
+    IPV6_PATHMTU: int
+    IPV6_RECVDSTOPTS: int
+    IPV6_RECVHOPLIMIT: int
+    IPV6_RECVHOPOPTS: int
+    IPV6_RECVPATHMTU: int
+    IPV6_RECVPKTINFO: int
+    IPV6_RTHDRDSTOPTS: int
 
 if sys.platform != "win32" and sys.platform != "linux":
-    if sys.version_info >= (3, 9) or sys.platform != "darwin":
-        IPV6_USE_MIN_MTU: int
+    IPV6_USE_MIN_MTU: int
 
 EAI_AGAIN: int
 EAI_BADFLAGS: int
@@ -414,16 +411,10 @@ if sys.platform == "linux":
 if sys.platform == "linux":
     # Availability: Linux >= 3.6
     CAN_RAW_FD_FRAMES: int
-
-if sys.platform == "linux" and sys.version_info >= (3, 9):
     # Availability: Linux >= 4.1
     CAN_RAW_JOIN_FILTERS: int
-
-if sys.platform == "linux":
     # Availability: Linux >= 2.6.25
     CAN_ISOTP: int
-
-if sys.platform == "linux" and sys.version_info >= (3, 9):
     # Availability: Linux >= 5.4
     CAN_J1939: int
 
@@ -566,18 +557,16 @@ if sys.platform == "linux":
     SO_VM_SOCKETS_BUFFER_MIN_SIZE: int
     VM_SOCKETS_INVALID_VERSION: int  # undocumented
 
-if sys.platform != "win32" or sys.version_info >= (3, 9):
-    # Documented as only available on BSD, macOS, but empirically sometimes
-    # available on Windows
-    if sys.platform != "linux":
-        AF_LINK: int
+# Documented as only available on BSD, macOS, but empirically sometimes
+# available on Windows
+if sys.platform != "linux":
+    AF_LINK: int
 
 has_ipv6: bool
 
 if sys.platform != "darwin" and sys.platform != "linux":
-    if sys.platform != "win32" or sys.version_info >= (3, 9):
-        BDADDR_ANY: str
-        BDADDR_LOCAL: str
+    BDADDR_ANY: str
+    BDADDR_LOCAL: str
 
 if sys.platform != "win32" and sys.platform != "darwin" and sys.platform != "linux":
     HCI_FILTER: int  # not in NetBSD or DragonFlyBSD
@@ -649,8 +638,7 @@ if sys.platform == "darwin":
     SYSPROTO_CONTROL: int
 
 if sys.platform != "darwin" and sys.platform != "linux":
-    if sys.version_info >= (3, 9) or sys.platform != "win32":
-        AF_BLUETOOTH: int
+    AF_BLUETOOTH: int
 
 if sys.platform != "win32" and sys.platform != "darwin" and sys.platform != "linux":
     # Linux and some BSD support is explicit in the docs
@@ -659,10 +647,9 @@ if sys.platform != "win32" and sys.platform != "darwin" and sys.platform != "lin
     BTPROTO_L2CAP: int
     BTPROTO_SCO: int  # not in FreeBSD
 if sys.platform != "darwin" and sys.platform != "linux":
-    if sys.version_info >= (3, 9) or sys.platform != "win32":
-        BTPROTO_RFCOMM: int
+    BTPROTO_RFCOMM: int
 
-if sys.version_info >= (3, 9) and sys.platform == "linux":
+if sys.platform == "linux":
     UDPLITE_RECV_CSCOV: int
     UDPLITE_SEND_CSCOV: int
 

stdlib/_tracemalloc.pyi

@@ -1,4 +1,3 @@
-import sys
 from collections.abc import Sequence
 from tracemalloc import _FrameTuple, _TraceTuple
 
@@ -9,9 +8,6 @@ def get_traceback_limit() -> int: ...
 def get_traced_memory() -> tuple[int, int]: ...
 def get_tracemalloc_memory() -> int: ...
 def is_tracing() -> bool: ...
-
-if sys.version_info >= (3, 9):
-    def reset_peak() -> None: ...
-
+def reset_peak() -> None: ...
 def start(nframe: int = 1, /) -> None: ...
 def stop() -> None: ...

stdlib/_weakrefset.pyi

@@ -1,11 +1,8 @@
-import sys
 from collections.abc import Iterable, Iterator, MutableSet
+from types import GenericAlias
 from typing import Any, ClassVar, TypeVar, overload
 from typing_extensions import Self
 
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
-
 __all__ = ["WeakSet"]
 
 _S = TypeVar("_S")
@@ -48,5 +45,4 @@ class WeakSet(MutableSet[_T]):
     def union(self, other: Iterable[_S]) -> WeakSet[_S | _T]: ...
     def __or__(self, other: Iterable[_S]) -> WeakSet[_S | _T]: ...
     def isdisjoint(self, other: Iterable[_T]) -> bool: ...
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...

stdlib/aifc.pyi

@@ -1,12 +1,8 @@
-import sys
 from types import TracebackType
 from typing import IO, Any, Literal, NamedTuple, overload
 from typing_extensions import Self, TypeAlias
 
-if sys.version_info >= (3, 9):
-    __all__ = ["Error", "open"]
-else:
-    __all__ = ["Error", "open", "openfp"]
+__all__ = ["Error", "open"]
 
 class Error(Exception): ...
 
@@ -81,11 +77,3 @@ def open(f: _File, mode: Literal["r", "rb"]) -> Aifc_read: ...
 def open(f: _File, mode: Literal["w", "wb"]) -> Aifc_write: ...
 @overload
 def open(f: _File, mode: str | None = None) -> Any: ...
-
-if sys.version_info < (3, 9):
-    @overload
-    def openfp(f: _File, mode: Literal["r", "rb"]) -> Aifc_read: ...
-    @overload
-    def openfp(f: _File, mode: Literal["w", "wb"]) -> Aifc_write: ...
-    @overload
-    def openfp(f: _File, mode: str | None = None) -> Any: ...

stdlib/argparse.pyi

@@ -17,6 +17,7 @@ __all__ = [
     "MetavarTypeHelpFormatter",
     "Namespace",
     "Action",
+    "BooleanOptionalAction",
     "ONE_OR_MORE",
     "OPTIONAL",
     "PARSER",
@@ -25,9 +26,6 @@ __all__ = [
     "ZERO_OR_MORE",
 ]
 
-if sys.version_info >= (3, 9):
-    __all__ += ["BooleanOptionalAction"]
-
 _T = TypeVar("_T")
 _ActionT = TypeVar("_ActionT", bound=Action)
 _ArgumentParserT = TypeVar("_ArgumentParserT", bound=ArgumentParser)
@@ -132,40 +130,22 @@ class ArgumentParser(_AttributeHolder, _ActionsContainer):
     _subparsers: _ArgumentGroup | None
 
     # Note: the constructor arguments are also used in _SubParsersAction.add_parser.
-    if sys.version_info >= (3, 9):
-        def __init__(
-            self,
-            prog: str | None = None,
-            usage: str | None = None,
-            description: str | None = None,
-            epilog: str | None = None,
-            parents: Sequence[ArgumentParser] = [],
-            formatter_class: _FormatterClass = ...,
-            prefix_chars: str = "-",
-            fromfile_prefix_chars: str | None = None,
-            argument_default: Any = None,
-            conflict_handler: str = "error",
-            add_help: bool = True,
-            allow_abbrev: bool = True,
-            exit_on_error: bool = True,
-        ) -> None: ...
-    else:
-        def __init__(
-            self,
-            prog: str | None = None,
-            usage: str | None = None,
-            description: str | None = None,
-            epilog: str | None = None,
-            parents: Sequence[ArgumentParser] = [],
-            formatter_class: _FormatterClass = ...,
-            prefix_chars: str = "-",
-            fromfile_prefix_chars: str | None = None,
-            argument_default: Any = None,
-            conflict_handler: str = "error",
-            add_help: bool = True,
-            allow_abbrev: bool = True,
-        ) -> None: ...
-
+    def __init__(
+        self,
+        prog: str | None = None,
+        usage: str | None = None,
+        description: str | None = None,
+        epilog: str | None = None,
+        parents: Sequence[ArgumentParser] = [],
+        formatter_class: _FormatterClass = ...,
+        prefix_chars: str = "-",
+        fromfile_prefix_chars: str | None = None,
+        argument_default: Any = None,
+        conflict_handler: str = "error",
+        add_help: bool = True,
+        allow_abbrev: bool = True,
+        exit_on_error: bool = True,
+    ) -> None: ...
     @overload
     def parse_args(self, args: Sequence[str] | None = None, namespace: None = None) -> Namespace: ...
     @overload
@@ -352,8 +332,7 @@ class Action(_AttributeHolder):
     def __call__(
         self, parser: ArgumentParser, namespace: Namespace, values: str | Sequence[Any] | None, option_string: str | None = None
     ) -> None: ...
-    if sys.version_info >= (3, 9):
-        def format_usage(self) -> str: ...
+    def format_usage(self) -> str: ...
 
 if sys.version_info >= (3, 12):
     class BooleanOptionalAction(Action):
@@ -418,7 +397,7 @@ if sys.version_info >= (3, 12):
                 metavar: str | tuple[str, ...] | None = sentinel,
             ) -> None: ...
 
-elif sys.version_info >= (3, 9):
+else:
     class BooleanOptionalAction(Action):
         @overload
         def __init__(
@@ -713,7 +692,7 @@ class _SubParsersAction(Action, Generic[_ArgumentParserT]):
             exit_on_error: bool = ...,
             **kwargs: Any,  # Accepting any additional kwargs for custom parser classes
         ) -> _ArgumentParserT: ...
-    elif sys.version_info >= (3, 9):
+    else:
         def add_parser(
             self,
             name: str,
@@ -736,28 +715,6 @@ class _SubParsersAction(Action, Generic[_ArgumentParserT]):
             exit_on_error: bool = ...,
             **kwargs: Any,  # Accepting any additional kwargs for custom parser classes
         ) -> _ArgumentParserT: ...
-    else:
-        def add_parser(
-            self,
-            name: str,
-            *,
-            help: str | None = ...,
-            aliases: Sequence[str] = ...,
-            # Kwargs from ArgumentParser constructor
-            prog: str | None = ...,
-            usage: str | None = ...,
-            description: str | None = ...,
-            epilog: str | None = ...,
-            parents: Sequence[_ArgumentParserT] = ...,
-            formatter_class: _FormatterClass = ...,
-            prefix_chars: str = ...,
-            fromfile_prefix_chars: str | None = ...,
-            argument_default: Any = ...,
-            conflict_handler: str = ...,
-            add_help: bool = ...,
-            allow_abbrev: bool = ...,
-            **kwargs: Any,  # Accepting any additional kwargs for custom parser classes
-        ) -> _ArgumentParserT: ...
 
     def _get_subactions(self) -> list[Action]: ...
 

stdlib/array.pyi

@@ -60,9 +60,6 @@ class array(MutableSequence[_T]):
     def tofile(self, f: SupportsWrite[bytes], /) -> None: ...
     def tolist(self) -> list[_T]: ...
     def tounicode(self) -> str: ...
-    if sys.version_info < (3, 9):
-        def fromstring(self, buffer: str | ReadableBuffer, /) -> None: ...
-        def tostring(self) -> bytes: ...
 
     __hash__: ClassVar[None]  # type: ignore[assignment]
     def __len__(self) -> int: ...

stdlib/asyncio/__init__.pyi

@@ -18,11 +18,9 @@ from .runners import *
 from .streams import *
 from .subprocess import *
 from .tasks import *
+from .threads import *
 from .transports import *
 
-if sys.version_info >= (3, 9):
-    from .threads import *
-
 if sys.version_info >= (3, 11):
     from .taskgroups import *
     from .timeouts import *
@@ -412,7 +410,7 @@ if sys.platform == "win32":
             "WindowsSelectorEventLoopPolicy",  # from windows_events
             "WindowsProactorEventLoopPolicy",  # from windows_events
         )
-    elif sys.version_info >= (3, 9):
+    else:
         __all__ = (
             "BaseEventLoop",  # from base_events
             "Server",  # from base_events
@@ -499,91 +497,6 @@ if sys.platform == "win32":
             "WindowsSelectorEventLoopPolicy",  # from windows_events
             "WindowsProactorEventLoopPolicy",  # from windows_events
         )
-    else:
-        __all__ = (
-            "BaseEventLoop",  # from base_events
-            "coroutine",  # from coroutines
-            "iscoroutinefunction",  # from coroutines
-            "iscoroutine",  # from coroutines
-            "AbstractEventLoopPolicy",  # from events
-            "AbstractEventLoop",  # from events
-            "AbstractServer",  # from events
-            "Handle",  # from events
-            "TimerHandle",  # from events
-            "get_event_loop_policy",  # from events
-            "set_event_loop_policy",  # from events
-            "get_event_loop",  # from events
-            "set_event_loop",  # from events
-            "new_event_loop",  # from events
-            "get_child_watcher",  # from events
-            "set_child_watcher",  # from events
-            "_set_running_loop",  # from events
-            "get_running_loop",  # from events
-            "_get_running_loop",  # from events
-            "CancelledError",  # from exceptions
-            "InvalidStateError",  # from exceptions
-            "TimeoutError",  # from exceptions
-            "IncompleteReadError",  # from exceptions
-            "LimitOverrunError",  # from exceptions
-            "SendfileNotAvailableError",  # from exceptions
-            "Future",  # from futures
-            "wrap_future",  # from futures
-            "isfuture",  # from futures
-            "Lock",  # from locks
-            "Event",  # from locks
-            "Condition",  # from locks
-            "Semaphore",  # from locks
-            "BoundedSemaphore",  # from locks
-            "BaseProtocol",  # from protocols
-            "Protocol",  # from protocols
-            "DatagramProtocol",  # from protocols
-            "SubprocessProtocol",  # from protocols
-            "BufferedProtocol",  # from protocols
-            "run",  # from runners
-            "Queue",  # from queues
-            "PriorityQueue",  # from queues
-            "LifoQueue",  # from queues
-            "QueueFull",  # from queues
-            "QueueEmpty",  # from queues
-            "StreamReader",  # from streams
-            "StreamWriter",  # from streams
-            "StreamReaderProtocol",  # from streams
-            "open_connection",  # from streams
-            "start_server",  # from streams
-            "create_subprocess_exec",  # from subprocess
-            "create_subprocess_shell",  # from subprocess
-            "Task",  # from tasks
-            "create_task",  # from tasks
-            "FIRST_COMPLETED",  # from tasks
-            "FIRST_EXCEPTION",  # from tasks
-            "ALL_COMPLETED",  # from tasks
-            "wait",  # from tasks
-            "wait_for",  # from tasks
-            "as_completed",  # from tasks
-            "sleep",  # from tasks
-            "gather",  # from tasks
-            "shield",  # from tasks
-            "ensure_future",  # from tasks
-            "run_coroutine_threadsafe",  # from tasks
-            "current_task",  # from tasks
-            "all_tasks",  # from tasks
-            "_register_task",  # from tasks
-            "_unregister_task",  # from tasks
-            "_enter_task",  # from tasks
-            "_leave_task",  # from tasks
-            "BaseTransport",  # from transports
-            "ReadTransport",  # from transports
-            "WriteTransport",  # from transports
-            "Transport",  # from transports
-            "DatagramTransport",  # from transports
-            "SubprocessTransport",  # from transports
-            "SelectorEventLoop",  # from windows_events
-            "ProactorEventLoop",  # from windows_events
-            "IocpProactor",  # from windows_events
-            "DefaultEventLoopPolicy",  # from windows_events
-            "WindowsSelectorEventLoopPolicy",  # from windows_events
-            "WindowsProactorEventLoopPolicy",  # from windows_events
-        )
 else:
     if sys.version_info >= (3, 14):
         __all__ = (
@@ -974,7 +887,7 @@ else:
             "ThreadedChildWatcher",  # from unix_events
             "DefaultEventLoopPolicy",  # from unix_events
         )
-    elif sys.version_info >= (3, 9):
+    else:
         __all__ = (
             "BaseEventLoop",  # from base_events
             "Server",  # from base_events
@@ -1065,94 +978,6 @@ else:
             "ThreadedChildWatcher",  # from unix_events
             "DefaultEventLoopPolicy",  # from unix_events
         )
-    else:
-        __all__ = (
-            "BaseEventLoop",  # from base_events
-            "coroutine",  # from coroutines
-            "iscoroutinefunction",  # from coroutines
-            "iscoroutine",  # from coroutines
-            "AbstractEventLoopPolicy",  # from events
-            "AbstractEventLoop",  # from events
-            "AbstractServer",  # from events
-            "Handle",  # from events
-            "TimerHandle",  # from events
-            "get_event_loop_policy",  # from events
-            "set_event_loop_policy",  # from events
-            "get_event_loop",  # from events
-            "set_event_loop",  # from events
-            "new_event_loop",  # from events
-            "get_child_watcher",  # from events
-            "set_child_watcher",  # from events
-            "_set_running_loop",  # from events
-            "get_running_loop",  # from events
-            "_get_running_loop",  # from events
-            "CancelledError",  # from exceptions
-            "InvalidStateError",  # from exceptions
-            "TimeoutError",  # from exceptions
-            "IncompleteReadError",  # from exceptions
-            "LimitOverrunError",  # from exceptions
-            "SendfileNotAvailableError",  # from exceptions
-            "Future",  # from futures
-            "wrap_future",  # from futures
-            "isfuture",  # from futures
-            "Lock",  # from locks
-            "Event",  # from locks
-            "Condition",  # from locks
-            "Semaphore",  # from locks
-            "BoundedSemaphore",  # from locks
-            "BaseProtocol",  # from protocols
-            "Protocol",  # from protocols
-            "DatagramProtocol",  # from protocols
-            "SubprocessProtocol",  # from protocols
-            "BufferedProtocol",  # from protocols
-            "run",  # from runners
-            "Queue",  # from queues
-            "PriorityQueue",  # from queues
-            "LifoQueue",  # from queues
-            "QueueFull",  # from queues
-            "QueueEmpty",  # from queues
-            "StreamReader",  # from streams
-            "StreamWriter",  # from streams
-            "StreamReaderProtocol",  # from streams
-            "open_connection",  # from streams
-            "start_server",  # from streams
-            "open_unix_connection",  # from streams
-            "start_unix_server",  # from streams
-            "create_subprocess_exec",  # from subprocess
-            "create_subprocess_shell",  # from subprocess
-            "Task",  # from tasks
-            "create_task",  # from tasks
-            "FIRST_COMPLETED",  # from tasks
-            "FIRST_EXCEPTION",  # from tasks
-            "ALL_COMPLETED",  # from tasks
-            "wait",  # from tasks
-            "wait_for",  # from tasks
-            "as_completed",  # from tasks
-            "sleep",  # from tasks
-            "gather",  # from tasks
-            "shield",  # from tasks
-            "ensure_future",  # from tasks
-            "run_coroutine_threadsafe",  # from tasks
-            "current_task",  # from tasks
-            "all_tasks",  # from tasks
-            "_register_task",  # from tasks
-            "_unregister_task",  # from tasks
-            "_enter_task",  # from tasks
-            "_leave_task",  # from tasks
-            "BaseTransport",  # from transports
-            "ReadTransport",  # from transports
-            "WriteTransport",  # from transports
-            "Transport",  # from transports
-            "DatagramTransport",  # from transports
-            "SubprocessTransport",  # from transports
-            "SelectorEventLoop",  # from unix_events
-            "AbstractChildWatcher",  # from unix_events
-            "SafeChildWatcher",  # from unix_events
-            "FastChildWatcher",  # from unix_events
-            "MultiLoopChildWatcher",  # from unix_events
-            "ThreadedChildWatcher",  # from unix_events
-            "DefaultEventLoopPolicy",  # from unix_events
-        )
 
 _T_co = TypeVar("_T_co", covariant=True)
 

stdlib/asyncio/base_events.pyi

@@ -15,10 +15,7 @@ from typing import IO, Any, Literal, TypeVar, overload
 from typing_extensions import TypeAlias, TypeVarTuple, Unpack
 
 # Keep asyncio.__all__ updated with any changes to __all__ here
-if sys.version_info >= (3, 9):
-    __all__ = ("BaseEventLoop", "Server")
-else:
-    __all__ = ("BaseEventLoop",)
+__all__ = ("BaseEventLoop", "Server")
 
 _T = TypeVar("_T")
 _Ts = TypeVarTuple("_Ts")
@@ -485,7 +482,7 @@ class BaseEventLoop(AbstractEventLoop):
     def set_debug(self, enabled: bool) -> None: ...
     if sys.version_info >= (3, 12):
         async def shutdown_default_executor(self, timeout: float | None = None) -> None: ...
-    elif sys.version_info >= (3, 9):
+    else:
         async def shutdown_default_executor(self) -> None: ...
 
     def __del__(self) -> None: ...

stdlib/asyncio/events.pyi

@@ -138,27 +138,19 @@ class AbstractEventLoop:
     @abstractmethod
     async def shutdown_asyncgens(self) -> None: ...
     # Methods scheduling callbacks.  All these return Handles.
-    if sys.version_info >= (3, 9):  # "context" added in 3.9.10/3.10.2
-        @abstractmethod
-        def call_soon(
-            self, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts], context: Context | None = None
-        ) -> Handle: ...
-        @abstractmethod
-        def call_later(
-            self, delay: float, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts], context: Context | None = None
-        ) -> TimerHandle: ...
-        @abstractmethod
-        def call_at(
-            self, when: float, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts], context: Context | None = None
-        ) -> TimerHandle: ...
-    else:
-        @abstractmethod
-        def call_soon(self, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts]) -> Handle: ...
-        @abstractmethod
-        def call_later(self, delay: float, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts]) -> TimerHandle: ...
-        @abstractmethod
-        def call_at(self, when: float, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts]) -> TimerHandle: ...
-
+    # "context" added in 3.9.10/3.10.2 for call_*
+    @abstractmethod
+    def call_soon(
+        self, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts], context: Context | None = None
+    ) -> Handle: ...
+    @abstractmethod
+    def call_later(
+        self, delay: float, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts], context: Context | None = None
+    ) -> TimerHandle: ...
+    @abstractmethod
+    def call_at(
+        self, when: float, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts], context: Context | None = None
+    ) -> TimerHandle: ...
     @abstractmethod
     def time(self) -> float: ...
     # Future methods
@@ -179,15 +171,11 @@ class AbstractEventLoop:
     @abstractmethod
     def get_task_factory(self) -> _TaskFactory | None: ...
     # Methods for interacting with threads
-    if sys.version_info >= (3, 9):  # "context" added in 3.9.10/3.10.2
-        @abstractmethod
-        def call_soon_threadsafe(
-            self, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts], context: Context | None = None
-        ) -> Handle: ...
-    else:
-        @abstractmethod
-        def call_soon_threadsafe(self, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts]) -> Handle: ...
-
+    # "context" added in 3.9.10/3.10.2
+    @abstractmethod
+    def call_soon_threadsafe(
+        self, callback: Callable[[Unpack[_Ts]], object], *args: Unpack[_Ts], context: Context | None = None
+    ) -> Handle: ...
     @abstractmethod
     def run_in_executor(self, executor: Executor | None, func: Callable[[Unpack[_Ts]], _T], *args: Unpack[_Ts]) -> Future[_T]: ...
     @abstractmethod
@@ -607,9 +595,8 @@ class AbstractEventLoop:
     def get_debug(self) -> bool: ...
     @abstractmethod
     def set_debug(self, enabled: bool) -> None: ...
-    if sys.version_info >= (3, 9):
-        @abstractmethod
-        async def shutdown_default_executor(self) -> None: ...
+    @abstractmethod
+    async def shutdown_default_executor(self) -> None: ...
 
 class AbstractEventLoopPolicy:
     @abstractmethod

stdlib/asyncio/locks.pyi

@@ -2,7 +2,7 @@ import enum
 import sys
 from _typeshed import Unused
 from collections import deque
-from collections.abc import Callable, Generator
+from collections.abc import Callable
 from types import TracebackType
 from typing import Any, Literal, TypeVar
 from typing_extensions import Self
@@ -23,29 +23,11 @@ else:
 
 _T = TypeVar("_T")
 
-if sys.version_info >= (3, 9):
-    class _ContextManagerMixin:
-        async def __aenter__(self) -> None: ...
-        async def __aexit__(
-            self, exc_type: type[BaseException] | None, exc: BaseException | None, tb: TracebackType | None
-        ) -> None: ...
-
-else:
-    class _ContextManager:
-        def __init__(self, lock: Lock | Semaphore) -> None: ...
-        def __enter__(self) -> None: ...
-        def __exit__(self, *args: Unused) -> None: ...
-
-    class _ContextManagerMixin:
-        # Apparently this exists to *prohibit* use as a context manager.
-        # def __enter__(self) -> NoReturn: ... see: https://github.com/python/typing/issues/1043
-        # def __exit__(self, *args: Any) -> None: ...
-        def __iter__(self) -> Generator[Any, None, _ContextManager]: ...
-        def __await__(self) -> Generator[Any, None, _ContextManager]: ...
-        async def __aenter__(self) -> None: ...
-        async def __aexit__(
-            self, exc_type: type[BaseException] | None, exc: BaseException | None, tb: TracebackType | None
-        ) -> None: ...
+class _ContextManagerMixin:
+    async def __aenter__(self) -> None: ...
+    async def __aexit__(
+        self, exc_type: type[BaseException] | None, exc: BaseException | None, tb: TracebackType | None
+    ) -> None: ...
 
 class Lock(_ContextManagerMixin, _LoopBoundMixin):
     _waiters: deque[Future[Any]] | None

stdlib/asyncio/queues.pyi

@@ -1,10 +1,8 @@
 import sys
 from asyncio.events import AbstractEventLoop
+from types import GenericAlias
 from typing import Any, Generic, TypeVar
 
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
-
 if sys.version_info >= (3, 10):
     from .mixins import _LoopBoundMixin
 else:
@@ -48,8 +46,7 @@ class Queue(Generic[_T], _LoopBoundMixin):  # noqa: Y059
     def get_nowait(self) -> _T: ...
     async def join(self) -> None: ...
     def task_done(self) -> None: ...
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, type: Any, /) -> GenericAlias: ...
+    def __class_getitem__(cls, type: Any, /) -> GenericAlias: ...
     if sys.version_info >= (3, 13):
         def shutdown(self, immediate: bool = False) -> None: ...
 

stdlib/asyncio/tasks.pyi

@@ -407,10 +407,8 @@ else:
 
 if sys.version_info >= (3, 12):
     _TaskCompatibleCoro: TypeAlias = Coroutine[Any, Any, _T_co]
-elif sys.version_info >= (3, 9):
-    _TaskCompatibleCoro: TypeAlias = Generator[_TaskYieldType, None, _T_co] | Coroutine[Any, Any, _T_co]
 else:
-    _TaskCompatibleCoro: TypeAlias = Generator[_TaskYieldType, None, _T_co] | Awaitable[_T_co]
+    _TaskCompatibleCoro: TypeAlias = Generator[_TaskYieldType, None, _T_co] | Coroutine[Any, Any, _T_co]
 
 def all_tasks(loop: AbstractEventLoop | None = None) -> set[Task[Any]]: ...
 

stdlib/asyncio/unix_events.pyi

@@ -30,7 +30,7 @@ if sys.platform != "win32":
             "DefaultEventLoopPolicy",
             "EventLoop",
         )
-    elif sys.version_info >= (3, 9):
+    else:
         # adds PidfdChildWatcher
         __all__ = (
             "SelectorEventLoop",
@@ -42,16 +42,6 @@ if sys.platform != "win32":
             "ThreadedChildWatcher",
             "DefaultEventLoopPolicy",
         )
-    else:
-        __all__ = (
-            "SelectorEventLoop",
-            "AbstractChildWatcher",
-            "SafeChildWatcher",
-            "FastChildWatcher",
-            "MultiLoopChildWatcher",
-            "ThreadedChildWatcher",
-            "DefaultEventLoopPolicy",
-        )
 
 # This is also technically not available on Win,
 # but other parts of typeshed need this definition.
@@ -239,16 +229,15 @@ if sys.platform != "win32":
             def remove_child_handler(self, pid: int) -> bool: ...
             def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
 
-        if sys.version_info >= (3, 9):
-            class PidfdChildWatcher(AbstractChildWatcher):
-                def __enter__(self) -> Self: ...
-                def __exit__(
-                    self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: types.TracebackType | None
-                ) -> None: ...
-                def is_active(self) -> bool: ...
-                def close(self) -> None: ...
-                def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
-                def add_child_handler(
-                    self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
-                ) -> None: ...
-                def remove_child_handler(self, pid: int) -> bool: ...
+        class PidfdChildWatcher(AbstractChildWatcher):
+            def __enter__(self) -> Self: ...
+            def __exit__(
+                self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: types.TracebackType | None
+            ) -> None: ...
+            def is_active(self) -> bool: ...
+            def close(self) -> None: ...
+            def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
+            def add_child_handler(
+                self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+            ) -> None: ...
+            def remove_child_handler(self, pid: int) -> bool: ...

stdlib/base64.pyi

@@ -56,10 +56,6 @@ def encode(input: IO[bytes], output: IO[bytes]) -> None: ...
 def encodebytes(s: ReadableBuffer) -> bytes: ...
 def decodebytes(s: ReadableBuffer) -> bytes: ...
 
-if sys.version_info < (3, 9):
-    def encodestring(s: ReadableBuffer) -> bytes: ...
-    def decodestring(s: ReadableBuffer) -> bytes: ...
-
 if sys.version_info >= (3, 13):
     def z85encode(s: ReadableBuffer) -> bytes: ...
     def z85decode(s: str | ReadableBuffer) -> bytes: ...

stdlib/bz2.pyi

@@ -1,10 +1,9 @@
 import _compression
-import sys
 from _bz2 import BZ2Compressor as BZ2Compressor, BZ2Decompressor as BZ2Decompressor
 from _compression import BaseStream
 from _typeshed import ReadableBuffer, StrOrBytesPath, WriteableBuffer
 from collections.abc import Iterable
-from typing import IO, Any, Literal, Protocol, SupportsIndex, TextIO, overload
+from typing import IO, Literal, Protocol, SupportsIndex, TextIO, overload
 from typing_extensions import Self, TypeAlias
 
 __all__ = ["BZ2File", "BZ2Compressor", "BZ2Decompressor", "open", "compress", "decompress"]
@@ -94,33 +93,14 @@ def open(
 
 class BZ2File(BaseStream, IO[bytes]):
     def __enter__(self) -> Self: ...
-    if sys.version_info >= (3, 9):
-        @overload
-        def __init__(self, filename: _WritableFileobj, mode: _WriteBinaryMode, *, compresslevel: int = 9) -> None: ...
-        @overload
-        def __init__(self, filename: _ReadableFileobj, mode: _ReadBinaryMode = "r", *, compresslevel: int = 9) -> None: ...
-        @overload
-        def __init__(
-            self, filename: StrOrBytesPath, mode: _ReadBinaryMode | _WriteBinaryMode = "r", *, compresslevel: int = 9
-        ) -> None: ...
-    else:
-        @overload
-        def __init__(
-            self, filename: _WritableFileobj, mode: _WriteBinaryMode, buffering: Any | None = None, compresslevel: int = 9
-        ) -> None: ...
-        @overload
-        def __init__(
-            self, filename: _ReadableFileobj, mode: _ReadBinaryMode = "r", buffering: Any | None = None, compresslevel: int = 9
-        ) -> None: ...
-        @overload
-        def __init__(
-            self,
-            filename: StrOrBytesPath,
-            mode: _ReadBinaryMode | _WriteBinaryMode = "r",
-            buffering: Any | None = None,
-            compresslevel: int = 9,
-        ) -> None: ...
-
+    @overload
+    def __init__(self, filename: _WritableFileobj, mode: _WriteBinaryMode, *, compresslevel: int = 9) -> None: ...
+    @overload
+    def __init__(self, filename: _ReadableFileobj, mode: _ReadBinaryMode = "r", *, compresslevel: int = 9) -> None: ...
+    @overload
+    def __init__(
+        self, filename: StrOrBytesPath, mode: _ReadBinaryMode | _WriteBinaryMode = "r", *, compresslevel: int = 9
+    ) -> None: ...
     def read(self, size: int | None = -1) -> bytes: ...
     def read1(self, size: int = -1) -> bytes: ...
     def readline(self, size: SupportsIndex = -1) -> bytes: ...  # type: ignore[override]

stdlib/collections/__init__.pyi

@@ -1,12 +1,10 @@
 import sys
 from _collections_abc import dict_items, dict_keys, dict_values
 from _typeshed import SupportsItems, SupportsKeysAndGetItem, SupportsRichComparison, SupportsRichComparisonT
+from types import GenericAlias
 from typing import Any, ClassVar, Generic, NoReturn, SupportsIndex, TypeVar, final, overload
 from typing_extensions import Self
 
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
-
 if sys.version_info >= (3, 10):
     from collections.abc import (
         Callable,
@@ -93,20 +91,19 @@ class UserDict(MutableMapping[_KT, _VT]):
     @classmethod
     @overload
     def fromkeys(cls, iterable: Iterable[_T], value: _S) -> UserDict[_T, _S]: ...
-    if sys.version_info >= (3, 9):
-        @overload
-        def __or__(self, other: UserDict[_KT, _VT] | dict[_KT, _VT]) -> Self: ...
-        @overload
-        def __or__(self, other: UserDict[_T1, _T2] | dict[_T1, _T2]) -> UserDict[_KT | _T1, _VT | _T2]: ...
-        @overload
-        def __ror__(self, other: UserDict[_KT, _VT] | dict[_KT, _VT]) -> Self: ...
-        @overload
-        def __ror__(self, other: UserDict[_T1, _T2] | dict[_T1, _T2]) -> UserDict[_KT | _T1, _VT | _T2]: ...
-        # UserDict.__ior__ should be kept roughly in line with MutableMapping.update()
-        @overload  # type: ignore[misc]
-        def __ior__(self, other: SupportsKeysAndGetItem[_KT, _VT]) -> Self: ...
-        @overload
-        def __ior__(self, other: Iterable[tuple[_KT, _VT]]) -> Self: ...
+    @overload
+    def __or__(self, other: UserDict[_KT, _VT] | dict[_KT, _VT]) -> Self: ...
+    @overload
+    def __or__(self, other: UserDict[_T1, _T2] | dict[_T1, _T2]) -> UserDict[_KT | _T1, _VT | _T2]: ...
+    @overload
+    def __ror__(self, other: UserDict[_KT, _VT] | dict[_KT, _VT]) -> Self: ...
+    @overload
+    def __ror__(self, other: UserDict[_T1, _T2] | dict[_T1, _T2]) -> UserDict[_KT | _T1, _VT | _T2]: ...
+    # UserDict.__ior__ should be kept roughly in line with MutableMapping.update()
+    @overload  # type: ignore[misc]
+    def __ior__(self, other: SupportsKeysAndGetItem[_KT, _VT]) -> Self: ...
+    @overload
+    def __ior__(self, other: Iterable[tuple[_KT, _VT]]) -> Self: ...
     if sys.version_info >= (3, 12):
         @overload
         def get(self, key: _KT, default: None = None) -> _VT | None: ...
@@ -213,10 +210,8 @@ class UserString(Sequence[UserString]):
     def lstrip(self, chars: str | None = None) -> Self: ...
     maketrans = str.maketrans
     def partition(self, sep: str) -> tuple[str, str, str]: ...
-    if sys.version_info >= (3, 9):
-        def removeprefix(self, prefix: str | UserString, /) -> Self: ...
-        def removesuffix(self, suffix: str | UserString, /) -> Self: ...
-
+    def removeprefix(self, prefix: str | UserString, /) -> Self: ...
+    def removesuffix(self, suffix: str | UserString, /) -> Self: ...
     def replace(self, old: str | UserString, new: str | UserString, maxsplit: int = -1) -> Self: ...
     def rfind(self, sub: str | UserString, start: int = 0, end: int = sys.maxsize) -> int: ...
     def rindex(self, sub: str | UserString, start: int = 0, end: int = sys.maxsize) -> int: ...
@@ -271,8 +266,7 @@ class deque(MutableSequence[_T]):
     def __gt__(self, value: deque[_T], /) -> bool: ...
     def __ge__(self, value: deque[_T], /) -> bool: ...
     def __eq__(self, value: object, /) -> bool: ...
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 class Counter(dict[_T, int], Generic[_T]):
     @overload
@@ -387,15 +381,14 @@ class OrderedDict(dict[_KT, _VT]):
     @overload
     def pop(self, key: _KT, default: _T) -> _VT | _T: ...
     def __eq__(self, value: object, /) -> bool: ...
-    if sys.version_info >= (3, 9):
-        @overload
-        def __or__(self, value: dict[_KT, _VT], /) -> Self: ...
-        @overload
-        def __or__(self, value: dict[_T1, _T2], /) -> OrderedDict[_KT | _T1, _VT | _T2]: ...
-        @overload
-        def __ror__(self, value: dict[_KT, _VT], /) -> Self: ...
-        @overload
-        def __ror__(self, value: dict[_T1, _T2], /) -> OrderedDict[_KT | _T1, _VT | _T2]: ...  # type: ignore[misc]
+    @overload
+    def __or__(self, value: dict[_KT, _VT], /) -> Self: ...
+    @overload
+    def __or__(self, value: dict[_T1, _T2], /) -> OrderedDict[_KT | _T1, _VT | _T2]: ...
+    @overload
+    def __ror__(self, value: dict[_KT, _VT], /) -> Self: ...
+    @overload
+    def __ror__(self, value: dict[_T1, _T2], /) -> OrderedDict[_KT | _T1, _VT | _T2]: ...  # type: ignore[misc]
 
 class defaultdict(dict[_KT, _VT]):
     default_factory: Callable[[], _VT] | None
@@ -435,15 +428,14 @@ class defaultdict(dict[_KT, _VT]):
     def __missing__(self, key: _KT, /) -> _VT: ...
     def __copy__(self) -> Self: ...
     def copy(self) -> Self: ...
-    if sys.version_info >= (3, 9):
-        @overload
-        def __or__(self, value: dict[_KT, _VT], /) -> Self: ...
-        @overload
-        def __or__(self, value: dict[_T1, _T2], /) -> defaultdict[_KT | _T1, _VT | _T2]: ...
-        @overload
-        def __ror__(self, value: dict[_KT, _VT], /) -> Self: ...
-        @overload
-        def __ror__(self, value: dict[_T1, _T2], /) -> defaultdict[_KT | _T1, _VT | _T2]: ...  # type: ignore[misc]
+    @overload
+    def __or__(self, value: dict[_KT, _VT], /) -> Self: ...
+    @overload
+    def __or__(self, value: dict[_T1, _T2], /) -> defaultdict[_KT | _T1, _VT | _T2]: ...
+    @overload
+    def __ror__(self, value: dict[_KT, _VT], /) -> Self: ...
+    @overload
+    def __ror__(self, value: dict[_T1, _T2], /) -> defaultdict[_KT | _T1, _VT | _T2]: ...  # type: ignore[misc]
 
 class ChainMap(MutableMapping[_KT, _VT]):
     maps: list[MutableMapping[_KT, _VT]]
@@ -488,17 +480,16 @@ class ChainMap(MutableMapping[_KT, _VT]):
     @classmethod
     @overload
     def fromkeys(cls, iterable: Iterable[_T], value: _S, /) -> ChainMap[_T, _S]: ...
-    if sys.version_info >= (3, 9):
-        @overload
-        def __or__(self, other: Mapping[_KT, _VT]) -> Self: ...
-        @overload
-        def __or__(self, other: Mapping[_T1, _T2]) -> ChainMap[_KT | _T1, _VT | _T2]: ...
-        @overload
-        def __ror__(self, other: Mapping[_KT, _VT]) -> Self: ...
-        @overload
-        def __ror__(self, other: Mapping[_T1, _T2]) -> ChainMap[_KT | _T1, _VT | _T2]: ...
-        # ChainMap.__ior__ should be kept roughly in line with MutableMapping.update()
-        @overload  # type: ignore[misc]
-        def __ior__(self, other: SupportsKeysAndGetItem[_KT, _VT]) -> Self: ...
-        @overload
-        def __ior__(self, other: Iterable[tuple[_KT, _VT]]) -> Self: ...
+    @overload
+    def __or__(self, other: Mapping[_KT, _VT]) -> Self: ...
+    @overload
+    def __or__(self, other: Mapping[_T1, _T2]) -> ChainMap[_KT | _T1, _VT | _T2]: ...
+    @overload
+    def __ror__(self, other: Mapping[_KT, _VT]) -> Self: ...
+    @overload
+    def __ror__(self, other: Mapping[_T1, _T2]) -> ChainMap[_KT | _T1, _VT | _T2]: ...
+    # ChainMap.__ior__ should be kept roughly in line with MutableMapping.update()
+    @overload  # type: ignore[misc]
+    def __ior__(self, other: SupportsKeysAndGetItem[_KT, _VT]) -> Self: ...
+    @overload
+    def __ior__(self, other: Iterable[tuple[_KT, _VT]]) -> Self: ...

stdlib/compileall.pyi

@@ -42,7 +42,7 @@ if sys.version_info >= (3, 10):
         hardlink_dupes: bool = False,
     ) -> bool: ...
 
-elif sys.version_info >= (3, 9):
+else:
     def compile_dir(
         dir: StrPath,
         maxlevels: int | None = None,
@@ -76,30 +76,6 @@ elif sys.version_info >= (3, 9):
         hardlink_dupes: bool = False,
     ) -> bool: ...
 
-else:
-    def compile_dir(
-        dir: StrPath,
-        maxlevels: int = 10,
-        ddir: StrPath | None = None,
-        force: bool = False,
-        rx: _SupportsSearch | None = None,
-        quiet: int = 0,
-        legacy: bool = False,
-        optimize: int = -1,
-        workers: int = 1,
-        invalidation_mode: PycInvalidationMode | None = None,
-    ) -> bool: ...
-    def compile_file(
-        fullname: StrPath,
-        ddir: StrPath | None = None,
-        force: bool = False,
-        rx: _SupportsSearch | None = None,
-        quiet: int = 0,
-        legacy: bool = False,
-        optimize: int = -1,
-        invalidation_mode: PycInvalidationMode | None = None,
-    ) -> bool: ...
-
 def compile_path(
     skip_curdir: bool = ...,
     maxlevels: int = 0,

stdlib/concurrent/futures/_base.pyi

@@ -1,15 +1,12 @@
 import sys
 import threading
 from _typeshed import Unused
-from collections.abc import Callable, Collection, Iterable, Iterator
+from collections.abc import Callable, Iterable, Iterator
 from logging import Logger
-from types import TracebackType
+from types import GenericAlias, TracebackType
 from typing import Any, Final, Generic, NamedTuple, Protocol, TypeVar
 from typing_extensions import ParamSpec, Self
 
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
-
 FIRST_COMPLETED: Final = "FIRST_COMPLETED"
 FIRST_EXCEPTION: Final = "FIRST_EXCEPTION"
 ALL_COMPLETED: Final = "ALL_COMPLETED"
@@ -53,23 +50,14 @@ class Future(Generic[_T]):
     def set_result(self, result: _T) -> None: ...
     def exception(self, timeout: float | None = None) -> BaseException | None: ...
     def set_exception(self, exception: BaseException | None) -> None: ...
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 class Executor:
-    if sys.version_info >= (3, 9):
-        def submit(self, fn: Callable[_P, _T], /, *args: _P.args, **kwargs: _P.kwargs) -> Future[_T]: ...
-    else:
-        def submit(self, fn: Callable[_P, _T], *args: _P.args, **kwargs: _P.kwargs) -> Future[_T]: ...
-
+    def submit(self, fn: Callable[_P, _T], /, *args: _P.args, **kwargs: _P.kwargs) -> Future[_T]: ...
     def map(
         self, fn: Callable[..., _T], *iterables: Iterable[Any], timeout: float | None = None, chunksize: int = 1
     ) -> Iterator[_T]: ...
-    if sys.version_info >= (3, 9):
-        def shutdown(self, wait: bool = True, *, cancel_futures: bool = False) -> None: ...
-    else:
-        def shutdown(self, wait: bool = True) -> None: ...
-
+    def shutdown(self, wait: bool = True, *, cancel_futures: bool = False) -> None: ...
     def __enter__(self) -> Self: ...
     def __exit__(
         self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
@@ -91,15 +79,9 @@ class DoneAndNotDoneFutures(NamedTuple, Generic[_T]):
     done: set[Future[_T]]
     not_done: set[Future[_T]]
 
-if sys.version_info >= (3, 9):
-    def wait(
-        fs: Iterable[Future[_T]], timeout: float | None = None, return_when: str = "ALL_COMPLETED"
-    ) -> DoneAndNotDoneFutures[_T]: ...
-
-else:
-    def wait(
-        fs: Collection[Future[_T]], timeout: float | None = None, return_when: str = "ALL_COMPLETED"
-    ) -> DoneAndNotDoneFutures[_T]: ...
+def wait(
+    fs: Iterable[Future[_T]], timeout: float | None = None, return_when: str = "ALL_COMPLETED"
+) -> DoneAndNotDoneFutures[_T]: ...
 
 class _Waiter:
     event: threading.Event

stdlib/concurrent/futures/process.pyi

@@ -84,7 +84,7 @@ class _SafeQueue(Queue[Future[Any]]):
             pending_work_items: dict[int, _WorkItem[Any]],
             thread_wakeup: _ThreadWakeup,
         ) -> None: ...
-    elif sys.version_info >= (3, 9):
+    else:
         def __init__(
             self,
             max_size: int | None = 0,
@@ -94,10 +94,6 @@ class _SafeQueue(Queue[Future[Any]]):
             shutdown_lock: Lock,
             thread_wakeup: _ThreadWakeup,
         ) -> None: ...
-    else:
-        def __init__(
-            self, max_size: int | None = 0, *, ctx: BaseContext, pending_work_items: dict[int, _WorkItem[Any]]
-        ) -> None: ...
 
     def _on_queue_feeder_error(self, e: Exception, obj: _CallItem) -> None: ...
 
@@ -135,27 +131,26 @@ else:
         initargs: tuple[Unpack[_Ts]],
     ) -> None: ...
 
-if sys.version_info >= (3, 9):
-    class _ExecutorManagerThread(Thread):
-        thread_wakeup: _ThreadWakeup
-        shutdown_lock: Lock
-        executor_reference: ref[Any]
-        processes: MutableMapping[int, Process]
-        call_queue: Queue[_CallItem]
-        result_queue: SimpleQueue[_ResultItem]
-        work_ids_queue: Queue[int]
-        pending_work_items: dict[int, _WorkItem[Any]]
-        def __init__(self, executor: ProcessPoolExecutor) -> None: ...
-        def run(self) -> None: ...
-        def add_call_item_to_queue(self) -> None: ...
-        def wait_result_broken_or_wakeup(self) -> tuple[Any, bool, str]: ...
-        def process_result_item(self, result_item: int | _ResultItem) -> None: ...
-        def is_shutting_down(self) -> bool: ...
-        def terminate_broken(self, cause: str) -> None: ...
-        def flag_executor_shutting_down(self) -> None: ...
-        def shutdown_workers(self) -> None: ...
-        def join_executor_internals(self) -> None: ...
-        def get_n_children_alive(self) -> int: ...
+class _ExecutorManagerThread(Thread):
+    thread_wakeup: _ThreadWakeup
+    shutdown_lock: Lock
+    executor_reference: ref[Any]
+    processes: MutableMapping[int, Process]
+    call_queue: Queue[_CallItem]
+    result_queue: SimpleQueue[_ResultItem]
+    work_ids_queue: Queue[int]
+    pending_work_items: dict[int, _WorkItem[Any]]
+    def __init__(self, executor: ProcessPoolExecutor) -> None: ...
+    def run(self) -> None: ...
+    def add_call_item_to_queue(self) -> None: ...
+    def wait_result_broken_or_wakeup(self) -> tuple[Any, bool, str]: ...
+    def process_result_item(self, result_item: int | _ResultItem) -> None: ...
+    def is_shutting_down(self) -> bool: ...
+    def terminate_broken(self, cause: str) -> None: ...
+    def flag_executor_shutting_down(self) -> None: ...
+    def shutdown_workers(self) -> None: ...
+    def join_executor_internals(self) -> None: ...
+    def get_n_children_alive(self) -> int: ...
 
 _system_limits_checked: bool
 _system_limited: bool | None
@@ -238,7 +233,6 @@ class ProcessPoolExecutor(Executor):
             initializer: Callable[[Unpack[_Ts]], object],
             initargs: tuple[Unpack[_Ts]],
         ) -> None: ...
-    if sys.version_info >= (3, 9):
-        def _start_executor_manager_thread(self) -> None: ...
 
+    def _start_executor_manager_thread(self) -> None: ...
     def _adjust_process_count(self) -> None: ...

stdlib/concurrent/futures/thread.pyi

@@ -1,7 +1,7 @@
 import queue
-import sys
 from collections.abc import Callable, Iterable, Mapping, Set as AbstractSet
 from threading import Lock, Semaphore, Thread
+from types import GenericAlias
 from typing import Any, Generic, TypeVar, overload
 from typing_extensions import TypeVarTuple, Unpack
 from weakref import ref
@@ -16,9 +16,6 @@ _global_shutdown_lock: Lock
 
 def _python_exit() -> None: ...
 
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
-
 _S = TypeVar("_S")
 
 class _WorkItem(Generic[_S]):
@@ -28,8 +25,7 @@ class _WorkItem(Generic[_S]):
     kwargs: Mapping[str, Any]
     def __init__(self, future: Future[_S], fn: Callable[..., _S], args: Iterable[Any], kwargs: Mapping[str, Any]) -> None: ...
     def run(self) -> None: ...
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 def _worker(
     executor_reference: ref[Any],

stdlib/contextlib.pyi

@@ -81,14 +81,9 @@ class _GeneratorContextManager(
     AbstractContextManager[_T_co, bool | None],
     ContextDecorator,
 ):
-    if sys.version_info >= (3, 9):
-        def __exit__(
-            self, typ: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None
-        ) -> bool | None: ...
-    else:
-        def __exit__(
-            self, type: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None
-        ) -> bool | None: ...
+    def __exit__(
+        self, typ: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None
+    ) -> bool | None: ...
 
 def contextmanager(func: Callable[_P, Iterator[_T_co]]) -> Callable[_P, _GeneratorContextManager[_T_co]]: ...
 

stdlib/ctypes/__init__.pyi

@@ -26,6 +26,7 @@ from _ctypes import (
 )
 from _typeshed import StrPath
 from ctypes._endian import BigEndianStructure as BigEndianStructure, LittleEndianStructure as LittleEndianStructure
+from types import GenericAlias
 from typing import Any, ClassVar, Generic, TypeVar, type_check_only
 from typing_extensions import Self, TypeAlias, deprecated
 
@@ -35,9 +36,6 @@ if sys.platform == "win32":
 if sys.version_info >= (3, 11):
     from ctypes._endian import BigEndianUnion as BigEndianUnion, LittleEndianUnion as LittleEndianUnion
 
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
-
 _T = TypeVar("_T")
 _DLLT = TypeVar("_DLLT", bound=CDLL)
 _CT = TypeVar("_CT", bound=_CData)
@@ -92,8 +90,7 @@ class LibraryLoader(Generic[_DLLT]):
     def __getattr__(self, name: str) -> _DLLT: ...
     def __getitem__(self, name: str) -> _DLLT: ...
     def LoadLibrary(self, name: str) -> _DLLT: ...
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 cdll: LibraryLoader[CDLL]
 if sys.platform == "win32":
@@ -151,9 +148,7 @@ c_buffer = create_string_buffer
 
 def create_unicode_buffer(init: int | str, size: int | None = None) -> Array[c_wchar]: ...
 @deprecated("Deprecated in Python 3.13; removal scheduled for Python 3.15")
-def SetPointerType(
-    pointer: type[_Pointer[Any]], cls: Any  # noqa: F811  # Redefinition of unused `pointer` from line 22
-) -> None: ...
+def SetPointerType(pointer: type[_Pointer[Any]], cls: Any) -> None: ...  # noqa: F811
 def ARRAY(typ: _CT, len: int) -> Array[_CT]: ...  # Soft Deprecated, no plans to remove
 
 if sys.platform == "win32":

stdlib/dataclasses.pyi

@@ -4,11 +4,9 @@ import types
 from _typeshed import DataclassInstance
 from builtins import type as Type  # alias to avoid name clashes with fields named "type"
 from collections.abc import Callable, Iterable, Mapping
+from types import GenericAlias
 from typing import Any, Generic, Literal, Protocol, TypeVar, overload
-from typing_extensions import Never, TypeAlias, TypeIs
-
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
+from typing_extensions import Never, TypeIs
 
 _T = TypeVar("_T")
 _T_co = TypeVar("_T_co", covariant=True)
@@ -142,8 +140,7 @@ class Field(Generic[_T]):
         ) -> None: ...
 
     def __set_name__(self, owner: Type[Any], name: str) -> None: ...
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 # NOTE: Actual return type is 'Field[_T]', but we want to help type checkers
 # to understand the magic that happens at runtime.
@@ -232,22 +229,13 @@ def is_dataclass(obj: object) -> TypeIs[DataclassInstance | type[DataclassInstan
 
 class FrozenInstanceError(AttributeError): ...
 
-if sys.version_info >= (3, 9):
-    _InitVarMeta: TypeAlias = type
-else:
-    class _InitVarMeta(type):
-        # Not used, instead `InitVar.__class_getitem__` is called.
-        # pyright (not unreasonably) thinks this is an invalid use of InitVar.
-        def __getitem__(self, params: Any) -> InitVar[Any]: ...  # pyright: ignore[reportInvalidTypeForm]
-
-class InitVar(Generic[_T], metaclass=_InitVarMeta):
+class InitVar(Generic[_T], metaclass=type):
     type: Type[_T]
     def __init__(self, type: Type[_T]) -> None: ...
-    if sys.version_info >= (3, 9):
-        @overload
-        def __class_getitem__(cls, type: Type[_T]) -> InitVar[_T]: ...  # pyright: ignore[reportInvalidTypeForm]
-        @overload
-        def __class_getitem__(cls, type: Any) -> InitVar[Any]: ...  # pyright: ignore[reportInvalidTypeForm]
+    @overload
+    def __class_getitem__(cls, type: Type[_T]) -> InitVar[_T]: ...  # pyright: ignore[reportInvalidTypeForm]
+    @overload
+    def __class_getitem__(cls, type: Any) -> InitVar[Any]: ...  # pyright: ignore[reportInvalidTypeForm]
 
 if sys.version_info >= (3, 12):
     def make_dataclass(

stdlib/datetime.pyi

@@ -6,7 +6,7 @@ from typing_extensions import CapsuleType, Self, TypeAlias, deprecated
 
 if sys.version_info >= (3, 11):
     __all__ = ("date", "datetime", "time", "timedelta", "timezone", "tzinfo", "MINYEAR", "MAXYEAR", "UTC")
-elif sys.version_info >= (3, 9):
+else:
     __all__ = ("date", "datetime", "time", "timedelta", "timezone", "tzinfo", "MINYEAR", "MAXYEAR")
 
 MINYEAR: Final = 1
@@ -39,18 +39,17 @@ class timezone(tzinfo):
 if sys.version_info >= (3, 11):
     UTC: timezone
 
-if sys.version_info >= (3, 9):
-    # This class calls itself datetime.IsoCalendarDate. It's neither
-    # NamedTuple nor structseq.
-    @final
-    @type_check_only
-    class _IsoCalendarDate(tuple[int, int, int]):
-        @property
-        def year(self) -> int: ...
-        @property
-        def week(self) -> int: ...
-        @property
-        def weekday(self) -> int: ...
+# This class calls itself datetime.IsoCalendarDate. It's neither
+# NamedTuple nor structseq.
+@final
+@type_check_only
+class _IsoCalendarDate(tuple[int, int, int]):
+    @property
+    def year(self) -> int: ...
+    @property
+    def week(self) -> int: ...
+    @property
+    def weekday(self) -> int: ...
 
 class date:
     min: ClassVar[date]
@@ -106,10 +105,7 @@ class date:
     def __hash__(self) -> int: ...
     def weekday(self) -> int: ...
     def isoweekday(self) -> int: ...
-    if sys.version_info >= (3, 9):
-        def isocalendar(self) -> _IsoCalendarDate: ...
-    else:
-        def isocalendar(self) -> tuple[int, int, int]: ...
+    def isocalendar(self) -> _IsoCalendarDate: ...
 
 class time:
     min: ClassVar[time]

stdlib/difflib.pyi

@@ -1,10 +1,7 @@
-import sys
 from collections.abc import Callable, Iterable, Iterator, Sequence
+from types import GenericAlias
 from typing import Any, AnyStr, Generic, Literal, NamedTuple, TypeVar, overload
 
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
-
 __all__ = [
     "get_close_matches",
     "ndiff",
@@ -43,19 +40,14 @@ class SequenceMatcher(Generic[_T]):
     def set_seqs(self, a: Sequence[_T], b: Sequence[_T]) -> None: ...
     def set_seq1(self, a: Sequence[_T]) -> None: ...
     def set_seq2(self, b: Sequence[_T]) -> None: ...
-    if sys.version_info >= (3, 9):
-        def find_longest_match(self, alo: int = 0, ahi: int | None = None, blo: int = 0, bhi: int | None = None) -> Match: ...
-    else:
-        def find_longest_match(self, alo: int, ahi: int, blo: int, bhi: int) -> Match: ...
-
+    def find_longest_match(self, alo: int = 0, ahi: int | None = None, blo: int = 0, bhi: int | None = None) -> Match: ...
     def get_matching_blocks(self) -> list[Match]: ...
     def get_opcodes(self) -> list[tuple[Literal["replace", "delete", "insert", "equal"], int, int, int, int]]: ...
     def get_grouped_opcodes(self, n: int = 3) -> Iterable[list[tuple[str, int, int, int, int]]]: ...
     def ratio(self) -> float: ...
     def quick_ratio(self) -> float: ...
     def real_quick_ratio(self) -> float: ...
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 @overload
 def get_close_matches(word: AnyStr, possibilities: Iterable[AnyStr], n: int = 3, cutoff: float = 0.6) -> list[AnyStr]: ...

stdlib/distutils/command/bdist_msi.pyi

@@ -21,8 +21,7 @@ if sys.platform == "win32":
         boolean_options: ClassVar[list[str]]
         all_versions: Incomplete
         other_version: str
-        if sys.version_info >= (3, 9):
-            def __init__(self, *args, **kw) -> None: ...
+        def __init__(self, *args, **kw) -> None: ...
         bdist_dir: Incomplete
         plat_name: Incomplete
         keep_temp: int

stdlib/encodings/raw_unicode_escape.pyi

@@ -1,5 +1,4 @@
 import codecs
-import sys
 from _typeshed import ReadableBuffer
 
 class Codec(codecs.Codec):
@@ -7,28 +6,18 @@ class Codec(codecs.Codec):
     @staticmethod
     def encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
     # At runtime, this is codecs.raw_unicode_escape_decode
-    if sys.version_info >= (3, 9):
-        @staticmethod
-        def decode(data: str | ReadableBuffer, errors: str | None = None, final: bool = True, /) -> tuple[str, int]: ...
-    else:
-        @staticmethod
-        def decode(data: str | ReadableBuffer, errors: str | None = None, /) -> tuple[str, int]: ...
+    @staticmethod
+    def decode(data: str | ReadableBuffer, errors: str | None = None, final: bool = True, /) -> tuple[str, int]: ...
 
 class IncrementalEncoder(codecs.IncrementalEncoder):
     def encode(self, input: str, final: bool = False) -> bytes: ...
 
-if sys.version_info >= (3, 9):
-    class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
-        def _buffer_decode(self, input: str | ReadableBuffer, errors: str | None, final: bool) -> tuple[str, int]: ...
-
-else:
-    class IncrementalDecoder(codecs.IncrementalDecoder):
-        def decode(self, input: str | ReadableBuffer, final: bool = False) -> str: ...
+class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+    def _buffer_decode(self, input: str | ReadableBuffer, errors: str | None, final: bool) -> tuple[str, int]: ...
 
 class StreamWriter(Codec, codecs.StreamWriter): ...
 
 class StreamReader(Codec, codecs.StreamReader):
-    if sys.version_info >= (3, 9):
-        def decode(self, input: str | ReadableBuffer, errors: str = "strict") -> tuple[str, int]: ...  # type: ignore[override]
+    def decode(self, input: str | ReadableBuffer, errors: str = "strict") -> tuple[str, int]: ...  # type: ignore[override]
 
 def getregentry() -> codecs.CodecInfo: ...

stdlib/encodings/unicode_escape.pyi

@@ -1,5 +1,4 @@
 import codecs
-import sys
 from _typeshed import ReadableBuffer
 
 class Codec(codecs.Codec):
@@ -7,28 +6,18 @@ class Codec(codecs.Codec):
     @staticmethod
     def encode(str: str, errors: str | None = None, /) -> tuple[bytes, int]: ...
     # At runtime, this is codecs.unicode_escape_decode
-    if sys.version_info >= (3, 9):
-        @staticmethod
-        def decode(data: str | ReadableBuffer, errors: str | None = None, final: bool = True, /) -> tuple[str, int]: ...
-    else:
-        @staticmethod
-        def decode(data: str | ReadableBuffer, errors: str | None = None, /) -> tuple[str, int]: ...
+    @staticmethod
+    def decode(data: str | ReadableBuffer, errors: str | None = None, final: bool = True, /) -> tuple[str, int]: ...
 
 class IncrementalEncoder(codecs.IncrementalEncoder):
     def encode(self, input: str, final: bool = False) -> bytes: ...
 
-if sys.version_info >= (3, 9):
-    class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
-        def _buffer_decode(self, input: str | ReadableBuffer, errors: str | None, final: bool) -> tuple[str, int]: ...
-
-else:
-    class IncrementalDecoder(codecs.IncrementalDecoder):
-        def decode(self, input: str | ReadableBuffer, final: bool = False) -> str: ...
+class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+    def _buffer_decode(self, input: str | ReadableBuffer, errors: str | None, final: bool) -> tuple[str, int]: ...
 
 class StreamWriter(Codec, codecs.StreamWriter): ...
 
 class StreamReader(Codec, codecs.StreamReader):
-    if sys.version_info >= (3, 9):
-        def decode(self, input: str | ReadableBuffer, errors: str = "strict") -> tuple[str, int]: ...  # type: ignore[override]
+    def decode(self, input: str | ReadableBuffer, errors: str = "strict") -> tuple[str, int]: ...  # type: ignore[override]
 
 def getregentry() -> codecs.CodecInfo: ...

stdlib/enum.pyi

@@ -100,20 +100,13 @@ class EnumMeta(type):
             _simple: bool = False,
             **kwds: Any,
         ) -> _typeshed.Self: ...
-    elif sys.version_info >= (3, 9):
+    else:
         def __new__(
             metacls: type[_typeshed.Self], cls: str, bases: tuple[type, ...], classdict: _EnumDict, **kwds: Any
         ) -> _typeshed.Self: ...
-    else:
-        def __new__(metacls: type[_typeshed.Self], cls: str, bases: tuple[type, ...], classdict: _EnumDict) -> _typeshed.Self: ...
-
-    if sys.version_info >= (3, 9):
-        @classmethod
-        def __prepare__(metacls, cls: str, bases: tuple[type, ...], **kwds: Any) -> _EnumDict: ...  # type: ignore[override]
-    else:
-        @classmethod
-        def __prepare__(metacls, cls: str, bases: tuple[type, ...]) -> _EnumDict: ...  # type: ignore[override]
 
+    @classmethod
+    def __prepare__(metacls, cls: str, bases: tuple[type, ...], **kwds: Any) -> _EnumDict: ...  # type: ignore[override]
     def __iter__(self: type[_EnumMemberT]) -> Iterator[_EnumMemberT]: ...
     def __reversed__(self: type[_EnumMemberT]) -> Iterator[_EnumMemberT]: ...
     if sys.version_info >= (3, 12):

stdlib/fcntl.pyi

@@ -26,8 +26,7 @@ if sys.platform != "win32":
     if sys.platform == "darwin":
         F_FULLFSYNC: int
         F_NOCACHE: int
-        if sys.version_info >= (3, 9):
-            F_GETPATH: int
+        F_GETPATH: int
     if sys.platform == "linux":
         F_SETLKW64: int
         F_SETSIG: int
@@ -43,10 +42,9 @@ if sys.platform != "win32":
         F_SEAL_SEAL: int
         F_SEAL_SHRINK: int
         F_SEAL_WRITE: int
-        if sys.version_info >= (3, 9):
-            F_OFD_GETLK: Final[int]
-            F_OFD_SETLK: Final[int]
-            F_OFD_SETLKW: Final[int]
+        F_OFD_GETLK: Final[int]
+        F_OFD_SETLK: Final[int]
+        F_OFD_SETLKW: Final[int]
 
         if sys.version_info >= (3, 10):
             F_GETPIPE_SZ: int

stdlib/filecmp.pyi

@@ -1,11 +1,9 @@
 import sys
 from _typeshed import GenericPath, StrOrBytesPath
 from collections.abc import Callable, Iterable, Sequence
+from types import GenericAlias
 from typing import Any, AnyStr, Final, Generic, Literal
 
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
-
 __all__ = ["clear_cache", "cmp", "dircmp", "cmpfiles", "DEFAULT_IGNORES"]
 
 DEFAULT_IGNORES: list[str]
@@ -62,7 +60,6 @@ class dircmp(Generic[AnyStr]):
     def phase3(self) -> None: ...
     def phase4(self) -> None: ...
     def phase4_closure(self) -> None: ...
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 def clear_cache() -> None: ...

stdlib/fileinput.pyi

@@ -1,13 +1,10 @@
 import sys
 from _typeshed import AnyStr_co, StrOrBytesPath
 from collections.abc import Callable, Iterable
-from types import TracebackType
+from types import GenericAlias, TracebackType
 from typing import IO, Any, AnyStr, Generic, Literal, Protocol, overload
 from typing_extensions import Self, TypeAlias
 
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
-
 __all__ = [
     "input",
     "close",
@@ -199,8 +196,7 @@ class FileInput(Generic[AnyStr]):
     def fileno(self) -> int: ...
     def isfirstline(self) -> bool: ...
     def isstdin(self) -> bool: ...
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 if sys.version_info >= (3, 10):
     def hook_compressed(

stdlib/fractions.pyi

@@ -1,24 +1,13 @@
 import sys
 from collections.abc import Callable
 from decimal import Decimal
-from numbers import Integral, Rational, Real
+from numbers import Rational, Real
 from typing import Any, Literal, Protocol, 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: ...
+__all__ = ["Fraction"]
 
 class _ConvertibleToIntegerRatio(Protocol):
     def as_integer_ratio(self) -> tuple[int | Rational, int | Rational]: ...

stdlib/ftplib.pyi

@@ -41,29 +41,17 @@ class FTP:
         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 | None = ...,
-            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 | None = ...,
-            source_address: tuple[str, int] | None = None,
-        ) -> None: ...
-
+    def __init__(
+        self,
+        host: str = "",
+        user: str = "",
+        passwd: str = "",
+        acct: str = "",
+        timeout: float | None = ...,
+        source_address: tuple[str, int] | None = None,
+        *,
+        encoding: str = "utf-8",
+    ) -> None: ...
     def connect(
         self, host: str = "", port: int = 0, timeout: float = -999, source_address: tuple[str, int] | None = None
     ) -> str: ...
@@ -131,7 +119,7 @@ class FTP_TLS(FTP):
             source_address: tuple[str, int] | None = None,
             encoding: str = "utf-8",
         ) -> None: ...
-    elif sys.version_info >= (3, 9):
+    else:
         def __init__(
             self,
             host: str = "",
@@ -146,19 +134,6 @@ class FTP_TLS(FTP):
             *,
             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 | None = ...,
-            source_address: tuple[str, int] | None = None,
-        ) -> None: ...
     ssl_version: int
     keyfile: str | None
     certfile: str | None

stdlib/functools.pyi

@@ -2,12 +2,10 @@ import sys
 import types
 from _typeshed import SupportsAllComparisons, SupportsItems
 from collections.abc import Callable, Hashable, Iterable, Sized
+from types import GenericAlias
 from typing import Any, Generic, Literal, NamedTuple, TypedDict, TypeVar, final, overload
 from typing_extensions import ParamSpec, Self, TypeAlias
 
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
-
 __all__ = [
     "update_wrapper",
     "wraps",
@@ -22,11 +20,9 @@ __all__ = [
     "singledispatch",
     "cached_property",
     "singledispatchmethod",
+    "cache",
 ]
 
-if sys.version_info >= (3, 9):
-    __all__ += ["cache"]
-
 _T = TypeVar("_T")
 _T_co = TypeVar("_T_co", covariant=True)
 _S = TypeVar("_S")
@@ -46,10 +42,9 @@ class _CacheInfo(NamedTuple):
     maxsize: int | None
     currsize: int
 
-if sys.version_info >= (3, 9):
-    class _CacheParameters(TypedDict):
-        maxsize: int
-        typed: bool
+class _CacheParameters(TypedDict):
+    maxsize: int
+    typed: bool
 
 @final
 class _lru_cache_wrapper(Generic[_T]):
@@ -57,9 +52,7 @@ class _lru_cache_wrapper(Generic[_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 cache_parameters(self) -> _CacheParameters: ...
     def __copy__(self) -> _lru_cache_wrapper[_T]: ...
     def __deepcopy__(self, memo: Any, /) -> _lru_cache_wrapper[_T]: ...
 
@@ -131,8 +124,7 @@ class partial(Generic[_T]):
     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: ...
+    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
@@ -148,8 +140,7 @@ class partialmethod(Generic[_T]):
     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: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 if sys.version_info >= (3, 11):
     _RegType: TypeAlias = type[Any] | types.UnionType
@@ -200,12 +191,9 @@ class cached_property(Generic[_T_co]):
     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_co) -> None: ...  # type: ignore[misc]  # pyright: ignore[reportGeneralTypeIssues]
-    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 __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
+def cache(user_function: Callable[..., _T], /) -> _lru_cache_wrapper[_T]: ...
 def _make_key(
     args: tuple[Hashable, ...],
     kwds: SupportsItems[Any, Any],

stdlib/gc.pyi

@@ -1,4 +1,3 @@
-import sys
 from collections.abc import Callable
 from typing import Any, Final, Literal
 from typing_extensions import TypeAlias
@@ -28,10 +27,7 @@ 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 is_finalized(obj: Any, /) -> bool: ...
 def isenabled() -> bool: ...
 def set_debug(flags: int, /) -> None: ...
 def set_threshold(threshold0: int, threshold1: int = ..., threshold2: int = ..., /) -> None: ...

stdlib/hashlib.pyi

@@ -5,16 +5,22 @@ from _hashlib import (
     _HashObject,
     openssl_md5 as md5,
     openssl_sha1 as sha1,
+    openssl_sha3_224 as sha3_224,
+    openssl_sha3_256 as sha3_256,
+    openssl_sha3_384 as sha3_384,
+    openssl_sha3_512 as sha3_512,
     openssl_sha224 as sha224,
     openssl_sha256 as sha256,
     openssl_sha384 as sha384,
     openssl_sha512 as sha512,
+    openssl_shake_128 as shake_128,
+    openssl_shake_256 as shake_256,
     pbkdf2_hmac as pbkdf2_hmac,
     scrypt as scrypt,
 )
 from _typeshed import ReadableBuffer
 from collections.abc import Callable, Set as AbstractSet
-from typing import Protocol, type_check_only
+from typing import Protocol
 
 if sys.version_info >= (3, 11):
     __all__ = (
@@ -60,31 +66,7 @@ else:
         "pbkdf2_hmac",
     )
 
-if sys.version_info >= (3, 9):
-    def new(name: str, data: ReadableBuffer = b"", *, usedforsecurity: bool = ...) -> HASH: ...
-    from _hashlib import (
-        openssl_sha3_224 as sha3_224,
-        openssl_sha3_256 as sha3_256,
-        openssl_sha3_384 as sha3_384,
-        openssl_sha3_512 as sha3_512,
-        openssl_shake_128 as shake_128,
-        openssl_shake_256 as shake_256,
-    )
-
-else:
-    @type_check_only
-    class _VarLenHash(HASH):
-        def digest(self, length: int) -> bytes: ...  # type: ignore[override]
-        def hexdigest(self, length: int) -> str: ...  # type: ignore[override]
-
-    def new(name: str, data: ReadableBuffer = b"") -> HASH: ...
-    # At runtime these aren't functions but classes imported from _sha3
-    def sha3_224(string: ReadableBuffer = b"") -> HASH: ...
-    def sha3_256(string: ReadableBuffer = b"") -> HASH: ...
-    def sha3_384(string: ReadableBuffer = b"") -> HASH: ...
-    def sha3_512(string: ReadableBuffer = b"") -> HASH: ...
-    def shake_128(string: ReadableBuffer = b"") -> _VarLenHash: ...
-    def shake_256(string: ReadableBuffer = b"") -> _VarLenHash: ...
+def new(name: str, data: ReadableBuffer = b"", *, usedforsecurity: bool = ...) -> HASH: ...
 
 algorithms_guaranteed: AbstractSet[str]
 algorithms_available: AbstractSet[str]

stdlib/hmac.pyi

@@ -1,9 +1,8 @@
-import sys
-from _hashlib import _HashObject
+from _hashlib import _HashObject, compare_digest as compare_digest
 from _typeshed import ReadableBuffer, SizedBuffer
 from collections.abc import Callable
 from types import ModuleType
-from typing import AnyStr, overload
+from typing import overload
 from typing_extensions import TypeAlias
 
 _DigestMod: TypeAlias = str | Callable[[], _HashObject] | ModuleType
@@ -32,11 +31,3 @@ class HMAC:
     def copy(self) -> HMAC: ...
 
 def digest(key: SizedBuffer, msg: ReadableBuffer, digest: _DigestMod) -> bytes: ...
-
-if sys.version_info >= (3, 9):
-    from _hashlib import compare_digest as compare_digest
-else:
-    @overload
-    def compare_digest(a: ReadableBuffer, b: ReadableBuffer, /) -> bool: ...
-    @overload
-    def compare_digest(a: AnyStr, b: AnyStr, /) -> bool: ...

stdlib/http/__init__.pyi

@@ -19,8 +19,7 @@ class HTTPStatus(IntEnum):
     CONTINUE = 100
     SWITCHING_PROTOCOLS = 101
     PROCESSING = 102
-    if sys.version_info >= (3, 9):
-        EARLY_HINTS = 103
+    EARLY_HINTS = 103
 
     OK = 200
     CREATED = 201
@@ -66,16 +65,14 @@ class HTTPStatus(IntEnum):
         RANGE_NOT_SATISFIABLE = 416
     REQUESTED_RANGE_NOT_SATISFIABLE = 416
     EXPECTATION_FAILED = 417
-    if sys.version_info >= (3, 9):
-        IM_A_TEAPOT = 418
+    IM_A_TEAPOT = 418
     MISDIRECTED_REQUEST = 421
     if sys.version_info >= (3, 13):
         UNPROCESSABLE_CONTENT = 422
     UNPROCESSABLE_ENTITY = 422
     LOCKED = 423
     FAILED_DEPENDENCY = 424
-    if sys.version_info >= (3, 9):
-        TOO_EARLY = 425
+    TOO_EARLY = 425
     UPGRADE_REQUIRED = 426
     PRECONDITION_REQUIRED = 428
     TOO_MANY_REQUESTS = 429

stdlib/http/client.pyi

@@ -44,8 +44,7 @@ HTTPS_PORT: int
 CONTINUE: Literal[100]
 SWITCHING_PROTOCOLS: Literal[101]
 PROCESSING: Literal[102]
-if sys.version_info >= (3, 9):
-    EARLY_HINTS: Literal[103]
+EARLY_HINTS: Literal[103]
 
 OK: Literal[200]
 CREATED: Literal[201]
@@ -91,16 +90,14 @@ if sys.version_info >= (3, 13):
     RANGE_NOT_SATISFIABLE: Literal[416]
 REQUESTED_RANGE_NOT_SATISFIABLE: Literal[416]
 EXPECTATION_FAILED: Literal[417]
-if sys.version_info >= (3, 9):
-    IM_A_TEAPOT: Literal[418]
+IM_A_TEAPOT: Literal[418]
 MISDIRECTED_REQUEST: Literal[421]
 if sys.version_info >= (3, 13):
     UNPROCESSABLE_CONTENT: Literal[422]
 UNPROCESSABLE_ENTITY: Literal[422]
 LOCKED: Literal[423]
 FAILED_DEPENDENCY: Literal[424]
-if sys.version_info >= (3, 9):
-    TOO_EARLY: Literal[425]
+TOO_EARLY: Literal[425]
 UPGRADE_REQUIRED: Literal[426]
 PRECONDITION_REQUIRED: Literal[428]
 TOO_MANY_REQUESTS: Literal[429]

stdlib/http/cookies.pyi

@@ -1,11 +1,8 @@
-import sys
 from collections.abc import Iterable, Mapping
+from types import GenericAlias
 from typing import Any, Generic, TypeVar, overload
 from typing_extensions import TypeAlias
 
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
-
 __all__ = ["CookieError", "BaseCookie", "SimpleCookie"]
 
 _DataType: TypeAlias = str | Mapping[str, str | Morsel[Any]]
@@ -44,8 +41,7 @@ class Morsel(dict[str, Any], Generic[_T]):
     def OutputString(self, attrs: list[str] | None = None) -> str: ...
     def __eq__(self, morsel: object) -> bool: ...
     def __setitem__(self, K: str, V: Any) -> None: ...
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 class BaseCookie(dict[str, Morsel[_T]], Generic[_T]):
     def __init__(self, input: _DataType | None = None) -> None: ...

stdlib/imaplib.pyi

@@ -40,13 +40,8 @@ class IMAP4:
     welcome: bytes
     capabilities: tuple[str, ...]
     PROTOCOL_VERSION: str
-    if sys.version_info >= (3, 9):
-        def __init__(self, host: str = "", port: int = 143, timeout: float | None = None) -> None: ...
-        def open(self, host: str = "", port: int = 143, timeout: float | None = None) -> None: ...
-    else:
-        def __init__(self, host: str = "", port: int = 143) -> None: ...
-        def open(self, host: str = "", port: int = 143) -> None: ...
-
+    def __init__(self, host: str = "", port: int = 143, timeout: float | None = None) -> None: ...
+    def open(self, host: str = "", port: int = 143, timeout: float | None = None) -> None: ...
     def __getattr__(self, attr: str) -> Any: ...
     host: str
     port: int
@@ -101,9 +96,7 @@ class IMAP4:
     def thread(self, threading_algorithm: str, charset: str, *search_criteria: str) -> _CommandResults: ...
     def uid(self, command: str, *args: str) -> _CommandResults: ...
     def unsubscribe(self, mailbox: str) -> _CommandResults: ...
-    if sys.version_info >= (3, 9):
-        def unselect(self) -> _CommandResults: ...
-
+    def unselect(self) -> _CommandResults: ...
     def xatom(self, name: str, *args: str) -> _CommandResults: ...
     def print_log(self) -> None: ...
 
@@ -115,7 +108,7 @@ class IMAP4_SSL(IMAP4):
         def __init__(
             self, host: str = "", port: int = 993, *, ssl_context: SSLContext | None = None, timeout: float | None = None
         ) -> None: ...
-    elif sys.version_info >= (3, 9):
+    else:
         def __init__(
             self,
             host: str = "",
@@ -125,22 +118,9 @@ class IMAP4_SSL(IMAP4):
             ssl_context: SSLContext | None = None,
             timeout: float | None = None,
         ) -> None: ...
-    else:
-        def __init__(
-            self,
-            host: str = "",
-            port: int = 993,
-            keyfile: str | None = None,
-            certfile: str | None = None,
-            ssl_context: SSLContext | None = None,
-        ) -> None: ...
     sslobj: SSLSocket
     file: IO[Any]
-    if sys.version_info >= (3, 9):
-        def open(self, host: str = "", port: int | None = 993, timeout: float | None = None) -> None: ...
-    else:
-        def open(self, host: str = "", port: int | None = 993) -> None: ...
-
+    def open(self, host: str = "", port: int | None = 993, timeout: float | None = None) -> None: ...
     def ssl(self) -> SSLSocket: ...
 
 class IMAP4_stream(IMAP4):
@@ -150,10 +130,7 @@ class IMAP4_stream(IMAP4):
     process: subprocess.Popen[bytes]
     writefile: IO[Any]
     readfile: IO[Any]
-    if sys.version_info >= (3, 9):
-        def open(self, host: str | None = None, port: int | None = None, timeout: float | None = None) -> None: ...
-    else:
-        def open(self, host: str | None = None, port: int | None = None) -> None: ...
+    def open(self, host: str | None = None, port: int | None = None, timeout: float | None = None) -> None: ...
 
 class _Authenticator:
     mech: Callable[[bytes], bytes | bytearray | memoryview | str | None]

stdlib/importlib/abc.pyi

@@ -125,49 +125,48 @@ class ResourceReader(metaclass=ABCMeta):
     @abstractmethod
     def contents(self) -> Iterator[str]: ...
 
-if sys.version_info >= (3, 9):
-    @runtime_checkable
-    class Traversable(Protocol):
+@runtime_checkable
+class Traversable(Protocol):
+    @abstractmethod
+    def is_dir(self) -> bool: ...
+    @abstractmethod
+    def is_file(self) -> bool: ...
+    @abstractmethod
+    def iterdir(self) -> Iterator[Traversable]: ...
+    if sys.version_info >= (3, 11):
         @abstractmethod
-        def is_dir(self) -> bool: ...
+        def joinpath(self, *descendants: str) -> Traversable: ...
+    else:
         @abstractmethod
-        def is_file(self) -> bool: ...
-        @abstractmethod
-        def iterdir(self) -> Iterator[Traversable]: ...
-        if sys.version_info >= (3, 11):
-            @abstractmethod
-            def joinpath(self, *descendants: str) -> Traversable: ...
-        else:
-            @abstractmethod
-            def joinpath(self, child: str, /) -> Traversable: ...
+        def joinpath(self, child: str, /) -> Traversable: ...
 
-        # The documentation and runtime protocol allows *args, **kwargs arguments,
-        # but this would mean that all implementers would have to support them,
-        # which is not the case.
-        @overload
+    # The documentation and runtime protocol allows *args, **kwargs arguments,
+    # but this would mean that all implementers would have to support them,
+    # which is not the case.
+    @overload
+    @abstractmethod
+    def open(self, mode: Literal["r"] = "r", *, encoding: str | None = None, errors: str | None = None) -> IO[str]: ...
+    @overload
+    @abstractmethod
+    def open(self, mode: Literal["rb"]) -> IO[bytes]: ...
+    @property
+    @abstractmethod
+    def name(self) -> str: ...
+    if sys.version_info >= (3, 10):
+        def __truediv__(self, child: str, /) -> Traversable: ...
+    else:
         @abstractmethod
-        def open(self, mode: Literal["r"] = "r", *, encoding: str | None = None, errors: str | None = None) -> IO[str]: ...
-        @overload
-        @abstractmethod
-        def open(self, mode: Literal["rb"]) -> IO[bytes]: ...
-        @property
-        @abstractmethod
-        def name(self) -> str: ...
-        if sys.version_info >= (3, 10):
-            def __truediv__(self, child: str, /) -> Traversable: ...
-        else:
-            @abstractmethod
-            def __truediv__(self, child: str, /) -> Traversable: ...
+        def __truediv__(self, child: str, /) -> Traversable: ...
 
-        @abstractmethod
-        def read_bytes(self) -> bytes: ...
-        @abstractmethod
-        def read_text(self, encoding: str | None = None) -> str: ...
+    @abstractmethod
+    def read_bytes(self) -> bytes: ...
+    @abstractmethod
+    def read_text(self, encoding: str | None = None) -> str: ...
 
-    class TraversableResources(ResourceReader):
-        @abstractmethod
-        def files(self) -> Traversable: ...
-        def open_resource(self, resource: str) -> BufferedReader: ...
-        def resource_path(self, resource: Any) -> str: ...
-        def is_resource(self, path: str) -> bool: ...
-        def contents(self) -> Iterator[str]: ...
+class TraversableResources(ResourceReader):
+    @abstractmethod
+    def files(self) -> Traversable: ...
+    def open_resource(self, resource: str) -> BufferedReader: ...
+    def resource_path(self, resource: Any) -> str: ...
+    def is_resource(self, path: str) -> bool: ...
+    def contents(self) -> Iterator[str]: ...

stdlib/importlib/metadata/__init__.pyi

@@ -71,11 +71,10 @@ class EntryPoint(_EntryPointBase):
     def load(self) -> Any: ...  # Callable[[], Any] or an importable module
     @property
     def extras(self) -> list[str]: ...
-    if sys.version_info >= (3, 9):
-        @property
-        def module(self) -> str: ...
-        @property
-        def attr(self) -> str: ...
+    @property
+    def module(self) -> str: ...
+    @property
+    def attr(self) -> str: ...
     if sys.version_info >= (3, 10):
         dist: ClassVar[Distribution | None]
         def matches(

stdlib/importlib/resources/__init__.pyi

@@ -2,6 +2,7 @@ import os
 import sys
 from collections.abc import Iterator
 from contextlib import AbstractContextManager
+from importlib.abc import Traversable
 from pathlib import Path
 from types import ModuleType
 from typing import Any, BinaryIO, Literal, TextIO
@@ -12,13 +13,18 @@ if sys.version_info >= (3, 11):
 else:
     Package: TypeAlias = str | ModuleType
 
-if sys.version_info >= (3, 9):
-    from importlib.abc import Traversable
-
-__all__ = ["Package", "contents", "is_resource", "open_binary", "open_text", "path", "read_binary", "read_text"]
-
-if sys.version_info >= (3, 9):
-    __all__ += ["as_file", "files"]
+__all__ = [
+    "Package",
+    "as_file",
+    "contents",
+    "files",
+    "is_resource",
+    "open_binary",
+    "open_text",
+    "path",
+    "read_binary",
+    "read_text",
+]
 
 if sys.version_info >= (3, 10):
     __all__ += ["ResourceReader"]
@@ -57,13 +63,12 @@ else:
 
 if sys.version_info >= (3, 11):
     from importlib.resources._common import as_file as as_file
-elif sys.version_info >= (3, 9):
+else:
     def as_file(path: Traversable) -> AbstractContextManager[Path, Literal[False]]: ...
 
 if sys.version_info >= (3, 11):
     from importlib.resources._common import files as files
-
-elif sys.version_info >= (3, 9):
+else:
     def files(package: Package) -> Traversable: ...
 
 if sys.version_info >= (3, 10):

stdlib/inspect.pyi

@@ -616,8 +616,7 @@ class Attribute(NamedTuple):
 
 def classify_class_attrs(cls: type) -> list[Attribute]: ...
 
-if sys.version_info >= (3, 9):
-    class ClassFoundException(Exception): ...
+class ClassFoundException(Exception): ...
 
 if sys.version_info >= (3, 12):
     class BufferFlags(enum.IntFlag):

stdlib/ipaddress.pyi

@@ -36,9 +36,7 @@ class _BaseAddress(_IPAddressBase):
     def __hash__(self) -> int: ...
     def __int__(self) -> int: ...
     def __sub__(self, other: int) -> Self: ...
-    if sys.version_info >= (3, 9):
-        def __format__(self, fmt: str) -> str: ...
-
+    def __format__(self, fmt: str) -> str: ...
     def __eq__(self, other: object) -> bool: ...
     def __lt__(self, other: Self) -> bool: ...
     if sys.version_info >= (3, 11):
@@ -184,10 +182,8 @@ class IPv6Address(_BaseV6, _BaseAddress):
     def sixtofour(self) -> IPv4Address | None: ...
     @property
     def teredo(self) -> tuple[IPv4Address, IPv4Address] | None: ...
-    if sys.version_info >= (3, 9):
-        @property
-        def scope_id(self) -> str | None: ...
-
+    @property
+    def scope_id(self) -> str | None: ...
     def __hash__(self) -> int: ...
     def __eq__(self, other: object) -> bool: ...
 

stdlib/itertools.pyi

@@ -1,12 +1,10 @@
 import sys
 from _typeshed import MaybeNone
 from collections.abc import Callable, Iterable, Iterator
+from types import GenericAlias
 from typing import Any, Generic, Literal, SupportsComplex, SupportsFloat, SupportsIndex, SupportsInt, TypeVar, overload
 from typing_extensions import Self, TypeAlias
 
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
-
 _T = TypeVar("_T")
 _S = TypeVar("_S")
 _N = TypeVar("_N", int, float, SupportsFloat, SupportsInt, SupportsIndex, SupportsComplex)
@@ -68,8 +66,7 @@ class chain(Generic[_T]):
     @classmethod
     # We use type[Any] and not type[_S] to not lose the type inference from __iterable
     def from_iterable(cls: type[Any], iterable: Iterable[Iterable[_S]], /) -> chain[_S]: ...
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 class compress(Generic[_T]):
     def __new__(cls, data: Iterable[_T], selectors: Iterable[Any]) -> Self: ...

stdlib/keyword.pyi

@@ -1,11 +1,7 @@
-import sys
 from collections.abc import Sequence
 from typing import Final
 
-if sys.version_info >= (3, 9):
-    __all__ = ["iskeyword", "issoftkeyword", "kwlist", "softkwlist"]
-else:
-    __all__ = ["iskeyword", "kwlist"]
+__all__ = ["iskeyword", "issoftkeyword", "kwlist", "softkwlist"]
 
 def iskeyword(s: str, /) -> bool: ...
 
@@ -13,9 +9,8 @@ def iskeyword(s: str, /) -> bool: ...
 # type it as a sequence
 kwlist: Final[Sequence[str]]
 
-if sys.version_info >= (3, 9):
-    def issoftkeyword(s: str, /) -> bool: ...
+def issoftkeyword(s: str, /) -> bool: ...
 
-    # a list at runtime, but you're not meant to mutate it;
-    # type it as a sequence
-    softkwlist: Final[Sequence[str]]
+# a list at runtime, but you're not meant to mutate it;
+# type it as a sequence
+softkwlist: Final[Sequence[str]]

stdlib/linecache.pyi

@@ -1,12 +1,8 @@
-import sys
 from collections.abc import Callable
 from typing import Any
 from typing_extensions import TypeAlias
 
-if sys.version_info >= (3, 9):
-    __all__ = ["getline", "clearcache", "checkcache", "lazycache"]
-else:
-    __all__ = ["getline", "clearcache", "checkcache"]
+__all__ = ["getline", "clearcache", "checkcache", "lazycache"]
 
 _ModuleGlobals: TypeAlias = dict[str, Any]
 _ModuleMetadata: TypeAlias = tuple[int, float | None, list[str], str]

stdlib/logging/__init__.pyi

@@ -273,10 +273,7 @@ class Formatter:
     datefmt: str | None  # undocumented
     _style: PercentStyle  # undocumented
     default_time_format: str
-    if sys.version_info >= (3, 9):
-        default_msec_format: str | None
-    else:
-        default_msec_format: str
+    default_msec_format: str | None
 
     if sys.version_info >= (3, 10):
         def __init__(
@@ -577,37 +574,20 @@ if sys.version_info >= (3, 11):
     def getLevelNamesMapping() -> dict[str, int]: ...
 
 def makeLogRecord(dict: Mapping[str, object]) -> LogRecord: ...
-
-if sys.version_info >= (3, 9):
-    def basicConfig(
-        *,
-        filename: StrPath | None = ...,
-        filemode: str = ...,
-        format: str = ...,
-        datefmt: str | None = ...,
-        style: _FormatStyle = ...,
-        level: _Level | None = ...,
-        stream: SupportsWrite[str] | None = ...,
-        handlers: Iterable[Handler] | None = ...,
-        force: bool | None = ...,
-        encoding: str | None = ...,
-        errors: str | None = ...,
-    ) -> None: ...
-
-else:
-    def basicConfig(
-        *,
-        filename: StrPath | None = ...,
-        filemode: str = ...,
-        format: str = ...,
-        datefmt: str | None = ...,
-        style: _FormatStyle = ...,
-        level: _Level | None = ...,
-        stream: SupportsWrite[str] | None = ...,
-        handlers: Iterable[Handler] | None = ...,
-        force: bool = ...,
-    ) -> None: ...
-
+def basicConfig(
+    *,
+    filename: StrPath | None = ...,
+    filemode: str = ...,
+    format: str = ...,
+    datefmt: str | None = ...,
+    style: _FormatStyle = ...,
+    level: _Level | None = ...,
+    stream: SupportsWrite[str] | None = ...,
+    handlers: Iterable[Handler] | None = ...,
+    force: bool | None = ...,
+    encoding: str | None = ...,
+    errors: str | None = ...,
+) -> None: ...
 def shutdown(handlerList: Sequence[Any] = ...) -> None: ...  # handlerList is undocumented
 def setLoggerClass(klass: type[Logger]) -> None: ...
 def captureWarnings(capture: bool) -> None: ...
@@ -633,14 +613,10 @@ class FileHandler(StreamHandler[TextIOWrapper]):
     mode: str  # undocumented
     encoding: str | None  # undocumented
     delay: bool  # undocumented
-    if sys.version_info >= (3, 9):
-        errors: str | None  # undocumented
-        def __init__(
-            self, filename: StrPath, mode: str = "a", encoding: str | None = None, delay: bool = False, errors: str | None = None
-        ) -> None: ...
-    else:
-        def __init__(self, filename: StrPath, mode: str = "a", encoding: str | None = None, delay: bool = False) -> None: ...
-
+    errors: str | None  # undocumented
+    def __init__(
+        self, filename: StrPath, mode: str = "a", encoding: str | None = None, delay: bool = False, errors: str | None = None
+    ) -> None: ...
     def _open(self) -> TextIOWrapper: ...  # undocumented
 
 class NullHandler(Handler): ...

stdlib/logging/handlers.pyi

@@ -22,54 +22,34 @@ SYSLOG_TCP_PORT: Final[int]
 class WatchedFileHandler(FileHandler):
     dev: int  # undocumented
     ino: int  # undocumented
-    if sys.version_info >= (3, 9):
-        def __init__(
-            self, filename: StrPath, mode: str = "a", encoding: str | None = None, delay: bool = False, errors: str | None = None
-        ) -> None: ...
-    else:
-        def __init__(self, filename: StrPath, mode: str = "a", encoding: str | None = None, delay: bool = False) -> None: ...
-
+    def __init__(
+        self, filename: StrPath, mode: str = "a", encoding: str | None = None, delay: bool = False, errors: str | None = None
+    ) -> None: ...
     def _statstream(self) -> None: ...  # undocumented
     def reopenIfNeeded(self) -> None: ...
 
 class BaseRotatingHandler(FileHandler):
     namer: Callable[[str], str] | None
     rotator: Callable[[str, str], None] | None
-    if sys.version_info >= (3, 9):
-        def __init__(
-            self, filename: StrPath, mode: str, encoding: str | None = None, delay: bool = False, errors: str | None = None
-        ) -> None: ...
-    else:
-        def __init__(self, filename: StrPath, mode: str, encoding: str | None = None, delay: bool = False) -> None: ...
-
+    def __init__(
+        self, filename: StrPath, mode: str, encoding: str | None = None, delay: bool = False, errors: str | None = None
+    ) -> None: ...
     def rotation_filename(self, default_name: str) -> str: ...
     def rotate(self, source: str, dest: str) -> None: ...
 
 class RotatingFileHandler(BaseRotatingHandler):
     maxBytes: int  # undocumented
     backupCount: int  # undocumented
-    if sys.version_info >= (3, 9):
-        def __init__(
-            self,
-            filename: StrPath,
-            mode: str = "a",
-            maxBytes: int = 0,
-            backupCount: int = 0,
-            encoding: str | None = None,
-            delay: bool = False,
-            errors: str | None = None,
-        ) -> None: ...
-    else:
-        def __init__(
-            self,
-            filename: StrPath,
-            mode: str = "a",
-            maxBytes: int = 0,
-            backupCount: int = 0,
-            encoding: str | None = None,
-            delay: bool = False,
-        ) -> None: ...
-
+    def __init__(
+        self,
+        filename: StrPath,
+        mode: str = "a",
+        maxBytes: int = 0,
+        backupCount: int = 0,
+        encoding: str | None = None,
+        delay: bool = False,
+        errors: str | None = None,
+    ) -> None: ...
     def doRollover(self) -> None: ...
     def shouldRollover(self, record: LogRecord) -> int: ...  # undocumented
 
@@ -83,32 +63,18 @@ class TimedRotatingFileHandler(BaseRotatingHandler):
     dayOfWeek: int  # undocumented
     rolloverAt: int  # undocumented
     extMatch: Pattern[str]  # undocumented
-    if sys.version_info >= (3, 9):
-        def __init__(
-            self,
-            filename: StrPath,
-            when: str = "h",
-            interval: int = 1,
-            backupCount: int = 0,
-            encoding: str | None = None,
-            delay: bool = False,
-            utc: bool = False,
-            atTime: datetime.time | None = None,
-            errors: str | None = None,
-        ) -> None: ...
-    else:
-        def __init__(
-            self,
-            filename: StrPath,
-            when: str = "h",
-            interval: int = 1,
-            backupCount: int = 0,
-            encoding: str | None = None,
-            delay: bool = False,
-            utc: bool = False,
-            atTime: datetime.time | None = None,
-        ) -> None: ...
-
+    def __init__(
+        self,
+        filename: StrPath,
+        when: str = "h",
+        interval: int = 1,
+        backupCount: int = 0,
+        encoding: str | None = None,
+        delay: bool = False,
+        utc: bool = False,
+        atTime: datetime.time | None = None,
+        errors: str | None = None,
+    ) -> None: ...
     def doRollover(self) -> None: ...
     def shouldRollover(self, record: LogRecord) -> int: ...  # undocumented
     def computeRollover(self, currentTime: int) -> int: ...  # undocumented
@@ -155,13 +121,10 @@ class SysLogHandler(Handler):
     LOG_CRON: int
     LOG_AUTHPRIV: int
     LOG_FTP: int
-
-    if sys.version_info >= (3, 9):
-        LOG_NTP: int
-        LOG_SECURITY: int
-        LOG_CONSOLE: int
-        LOG_SOLCRON: int
-
+    LOG_NTP: int
+    LOG_SECURITY: int
+    LOG_CONSOLE: int
+    LOG_SOLCRON: int
     LOG_LOCAL0: int
     LOG_LOCAL1: int
     LOG_LOCAL2: int
@@ -248,8 +211,7 @@ class HTTPHandler(Handler):
         context: ssl.SSLContext | None = None,
     ) -> None: ...
     def mapLogRecord(self, record: LogRecord) -> dict[str, Any]: ...
-    if sys.version_info >= (3, 9):
-        def getConnection(self, host: str, secure: bool) -> http.client.HTTPConnection: ...  # undocumented
+    def getConnection(self, host: str, secure: bool) -> http.client.HTTPConnection: ...  # undocumented
 
 class _QueueLike(Protocol[_T]):
     def get(self) -> _T: ...

stdlib/mailbox.pyi

@@ -4,13 +4,10 @@ import sys
 from _typeshed import StrPath, SupportsNoArgReadline, SupportsRead
 from abc import ABCMeta, abstractmethod
 from collections.abc import Callable, Iterable, Iterator, Mapping, Sequence
-from types import TracebackType
+from types import GenericAlias, TracebackType
 from typing import IO, Any, AnyStr, Generic, Literal, Protocol, TypeVar, overload
 from typing_extensions import Self, TypeAlias
 
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
-
 __all__ = [
     "Mailbox",
     "Maildir",
@@ -101,8 +98,7 @@ class Mailbox(Generic[_MessageT]):
     def unlock(self) -> None: ...
     @abstractmethod
     def close(self) -> None: ...
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 class Maildir(Mailbox[MaildirMessage]):
     colon: str
@@ -251,8 +247,7 @@ class _ProxyFile(Generic[AnyStr]):
     def flush(self) -> None: ...
     @property
     def closed(self) -> bool: ...
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 class _PartialFile(_ProxyFile[AnyStr]):
     def __init__(self, f: IO[AnyStr], start: int | None = None, stop: int | None = None) -> None: ...

stdlib/math.pyi

@@ -61,13 +61,7 @@ def fmod(x: _SupportsFloatOrIndex, y: _SupportsFloatOrIndex, /) -> float: ...
 def frexp(x: _SupportsFloatOrIndex, /) -> tuple[float, int]: ...
 def fsum(seq: Iterable[_SupportsFloatOrIndex], /) -> float: ...
 def gamma(x: _SupportsFloatOrIndex, /) -> float: ...
-
-if sys.version_info >= (3, 9):
-    def gcd(*integers: SupportsIndex) -> int: ...
-
-else:
-    def gcd(x: SupportsIndex, y: SupportsIndex, /) -> int: ...
-
+def gcd(*integers: SupportsIndex) -> int: ...
 def hypot(*coordinates: _SupportsFloatOrIndex) -> float: ...
 def isclose(
     a: _SupportsFloatOrIndex,
@@ -80,10 +74,7 @@ def isinf(x: _SupportsFloatOrIndex, /) -> bool: ...
 def isfinite(x: _SupportsFloatOrIndex, /) -> bool: ...
 def isnan(x: _SupportsFloatOrIndex, /) -> bool: ...
 def isqrt(n: SupportsIndex, /) -> int: ...
-
-if sys.version_info >= (3, 9):
-    def lcm(*integers: SupportsIndex) -> int: ...
-
+def lcm(*integers: SupportsIndex) -> int: ...
 def ldexp(x: _SupportsFloatOrIndex, i: int, /) -> float: ...
 def lgamma(x: _SupportsFloatOrIndex, /) -> float: ...
 def log(x: _SupportsFloatOrIndex, base: _SupportsFloatOrIndex = ...) -> float: ...
@@ -95,7 +86,7 @@ def modf(x: _SupportsFloatOrIndex, /) -> tuple[float, float]: ...
 if sys.version_info >= (3, 12):
     def nextafter(x: _SupportsFloatOrIndex, y: _SupportsFloatOrIndex, /, *, steps: SupportsIndex | None = None) -> float: ...
 
-elif sys.version_info >= (3, 9):
+else:
     def nextafter(x: _SupportsFloatOrIndex, y: _SupportsFloatOrIndex, /) -> float: ...
 
 def perm(n: SupportsIndex, k: SupportsIndex | None = None, /) -> int: ...
@@ -140,9 +131,7 @@ class _SupportsTrunc(Protocol[_T_co]):
     def __trunc__(self) -> _T_co: ...
 
 def trunc(x: _SupportsTrunc[_T], /) -> _T: ...
-
-if sys.version_info >= (3, 9):
-    def ulp(x: _SupportsFloatOrIndex, /) -> float: ...
+def ulp(x: _SupportsFloatOrIndex, /) -> float: ...
 
 if sys.version_info >= (3, 13):
     def fma(x: _SupportsFloatOrIndex, y: _SupportsFloatOrIndex, z: _SupportsFloatOrIndex, /) -> float: ...

stdlib/multiprocessing/managers.pyi

@@ -3,7 +3,7 @@ import sys
 import threading
 from _typeshed import SupportsKeysAndGetItem, SupportsRichComparison, SupportsRichComparisonT
 from collections.abc import Callable, Iterable, Iterator, Mapping, MutableMapping, MutableSequence, Sequence
-from types import TracebackType
+from types import GenericAlias, TracebackType
 from typing import Any, AnyStr, ClassVar, Generic, SupportsIndex, TypeVar, overload
 from typing_extensions import Self, TypeAlias
 
@@ -15,9 +15,6 @@ from .util import Finalize as _Finalize
 
 __all__ = ["BaseManager", "SyncManager", "BaseProxy", "Token", "SharedMemoryManager"]
 
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
-
 _T = TypeVar("_T")
 _KT = TypeVar("_KT")
 _VT = TypeVar("_VT")
@@ -59,8 +56,7 @@ class ValueProxy(BaseProxy, Generic[_T]):
     def get(self) -> _T: ...
     def set(self, value: _T) -> None: ...
     value: _T
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 if sys.version_info >= (3, 13):
     class _BaseDictProxy(BaseProxy, MutableMapping[_KT, _VT]):

stdlib/multiprocessing/pool.pyi

@@ -1,13 +1,9 @@
-import sys
 from collections.abc import Callable, Iterable, Mapping
 from multiprocessing.context import DefaultContext, Process
-from types import TracebackType
+from types import GenericAlias, TracebackType
 from typing import Any, Final, Generic, TypeVar
 from typing_extensions import Self
 
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
-
 __all__ = ["Pool", "ThreadPool"]
 
 _S = TypeVar("_S")
@@ -21,8 +17,7 @@ class ApplyResult(Generic[_T]):
     def wait(self, timeout: float | None = None) -> None: ...
     def ready(self) -> bool: ...
     def successful(self) -> bool: ...
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 # alias created during issue #17805
 AsyncResult = ApplyResult

stdlib/multiprocessing/queues.pyi

@@ -1,9 +1,7 @@
 import sys
+from types import GenericAlias
 from typing import Any, Generic, TypeVar
 
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
-
 __all__ = ["Queue", "SimpleQueue", "JoinableQueue"]
 
 _T = TypeVar("_T")
@@ -31,11 +29,8 @@ class JoinableQueue(Queue[_T]):
 
 class SimpleQueue(Generic[_T]):
     def __init__(self, *, ctx: Any = ...) -> None: ...
-    if sys.version_info >= (3, 9):
-        def close(self) -> None: ...
-
+    def close(self) -> None: ...
     def empty(self) -> bool: ...
     def get(self) -> _T: ...
     def put(self, obj: _T) -> None: ...
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...

stdlib/multiprocessing/shared_memory.pyi

@@ -1,11 +1,9 @@
 import sys
 from collections.abc import Iterable
+from types import GenericAlias
 from typing import Any, Generic, TypeVar, overload
 from typing_extensions import Self
 
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
-
 __all__ = ["SharedMemory", "ShareableList"]
 
 _SLT = TypeVar("_SLT", int, float, bool, str, bytes, None)
@@ -40,5 +38,4 @@ class ShareableList(Generic[_SLT]):
     def format(self) -> str: ...
     def count(self, value: _SLT) -> int: ...
     def index(self, value: _SLT) -> int: ...
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...

stdlib/nntplib.pyi

@@ -1,7 +1,6 @@
 import datetime
 import socket
 import ssl
-import sys
 from _typeshed import Unused
 from builtins import list as _list  # conflicts with a method named "list"
 from collections.abc import Iterable
@@ -98,10 +97,6 @@ class NNTP:
     def over(
         self, message_spec: None | str | _list[Any] | tuple[Any, ...], *, file: _File = None
     ) -> tuple[str, _list[tuple[int, dict[str, str]]]]: ...
-    if sys.version_info < (3, 9):
-        def xgtitle(self, group: str, *, file: _File = None) -> tuple[str, _list[tuple[str, str]]]: ...
-        def xpath(self, id: Any) -> tuple[str, str]: ...
-
     def date(self) -> tuple[str, datetime.datetime]: ...
     def post(self, data: bytes | Iterable[bytes]) -> str: ...
     def ihave(self, message_id: Any, data: bytes | Iterable[bytes]) -> str: ...

stdlib/nt.pyi

@@ -89,14 +89,14 @@ if sys.platform == "win32":
         umask as umask,
         uname_result as uname_result,
         unlink as unlink,
+        unsetenv as unsetenv,
         urandom as urandom,
         utime as utime,
         waitpid as waitpid,
+        waitstatus_to_exitcode as waitstatus_to_exitcode,
         write as write,
     )
 
-    if sys.version_info >= (3, 9):
-        from os import unsetenv as unsetenv, waitstatus_to_exitcode as waitstatus_to_exitcode
     if sys.version_info >= (3, 11):
         from os import EX_OK as EX_OK
     if sys.version_info >= (3, 12):

stdlib/opcode.pyi

@@ -23,23 +23,7 @@ else:
 if sys.version_info >= (3, 13):
     __all__ += ["hasjump"]
 
-if sys.version_info >= (3, 9):
-    cmp_op: tuple[Literal["<"], Literal["<="], Literal["=="], Literal["!="], Literal[">"], Literal[">="]]
-else:
-    cmp_op: tuple[
-        Literal["<"],
-        Literal["<="],
-        Literal["=="],
-        Literal["!="],
-        Literal[">"],
-        Literal[">="],
-        Literal["in"],
-        Literal["not in"],
-        Literal["is"],
-        Literal["is not"],
-        Literal["exception match"],
-        Literal["BAD"],
-    ]
+cmp_op: tuple[Literal["<"], Literal["<="], Literal["=="], Literal["!="], Literal[">"], Literal[">="]]
 hasconst: list[int]
 hasname: list[int]
 hasjrel: list[int]

stdlib/pathlib.pyi

@@ -14,13 +14,10 @@ from _typeshed import (
 from collections.abc import Callable, Generator, Iterator, Sequence
 from io import BufferedRandom, BufferedReader, BufferedWriter, FileIO, TextIOWrapper
 from os import PathLike, stat_result
-from types import TracebackType
+from types import GenericAlias, TracebackType
 from typing import IO, Any, BinaryIO, ClassVar, Literal, overload
 from typing_extensions import Never, Self, deprecated
 
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
-
 __all__ = ["PurePath", "PurePosixPath", "PureWindowsPath", "Path", "PosixPath", "WindowsPath"]
 
 if sys.version_info >= (3, 13):
@@ -68,7 +65,7 @@ class PurePath(PathLike[str]):
     def is_reserved(self) -> bool: ...
     if sys.version_info >= (3, 12):
         def is_relative_to(self, other: StrPath, /, *_deprecated: StrPath) -> bool: ...
-    elif sys.version_info >= (3, 9):
+    else:
         def is_relative_to(self, *other: StrPath) -> bool: ...
 
     if sys.version_info >= (3, 12):
@@ -82,16 +79,14 @@ class PurePath(PathLike[str]):
         def relative_to(self, *other: StrPath) -> Self: ...
 
     def with_name(self, name: str) -> Self: ...
-    if sys.version_info >= (3, 9):
-        def with_stem(self, stem: str) -> Self: ...
-
+    def with_stem(self, stem: str) -> Self: ...
     def with_suffix(self, suffix: str) -> Self: ...
     def joinpath(self, *other: StrPath) -> Self: ...
     @property
     def parents(self) -> Sequence[Self]: ...
     @property
     def parent(self) -> Self: ...
-    if sys.version_info >= (3, 9) and sys.version_info < (3, 11):
+    if sys.version_info < (3, 11):
         def __class_getitem__(cls, type: Any) -> GenericAlias: ...
 
     if sys.version_info >= (3, 12):
@@ -247,8 +242,7 @@ class Path(PurePath):
     else:
         def is_mount(self) -> bool: ...
 
-    if sys.version_info >= (3, 9):
-        def readlink(self) -> Self: ...
+    def readlink(self) -> Self: ...
 
     if sys.version_info >= (3, 10):
         def rename(self, target: StrPath) -> Self: ...

stdlib/pkgutil.pyi

@@ -48,6 +48,4 @@ def walk_packages(
     path: Iterable[StrOrBytesPath] | None = None, prefix: str = "", onerror: Callable[[str], object] | None = None
 ) -> Iterator[ModuleInfo]: ...
 def get_data(package: str, resource: str) -> bytes | None: ...
-
-if sys.version_info >= (3, 9):
-    def resolve_name(name: str) -> Any: ...
+def resolve_name(name: str) -> Any: ...

stdlib/platform.pyi

@@ -15,40 +15,29 @@ def java_ver(
 def system_alias(system: str, release: str, version: str) -> tuple[str, str, str]: ...
 def architecture(executable: str = sys.executable, bits: str = "", linkage: str = "") -> tuple[str, str]: ...
 
-if sys.version_info >= (3, 9):
-    # This class is not exposed. It calls itself platform.uname_result_base.
-    # At runtime it only has 5 fields.
-    @type_check_only
-    class _uname_result_base(NamedTuple):
-        system: str
-        node: str
-        release: str
-        version: str
-        machine: str
-        # This base class doesn't have this field at runtime, but claiming it
-        # does is the least bad way to handle the situation. Nobody really
-        # sees this class anyway. See #13068
-        processor: str
+# This class is not exposed. It calls itself platform.uname_result_base.
+# At runtime it only has 5 fields.
+@type_check_only
+class _uname_result_base(NamedTuple):
+    system: str
+    node: str
+    release: str
+    version: str
+    machine: str
+    # This base class doesn't have this field at runtime, but claiming it
+    # does is the least bad way to handle the situation. Nobody really
+    # sees this class anyway. See #13068
+    processor: str
 
-    # uname_result emulates a 6-field named tuple, but the processor field
-    # is lazily evaluated rather than being passed in to the constructor.
-    class uname_result(_uname_result_base):
-        if sys.version_info >= (3, 10):
-            __match_args__ = ("system", "node", "release", "version", "machine")  # pyright: ignore[reportAssignmentType]
+# uname_result emulates a 6-field named tuple, but the processor field
+# is lazily evaluated rather than being passed in to the constructor.
+class uname_result(_uname_result_base):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("system", "node", "release", "version", "machine")  # pyright: ignore[reportAssignmentType]
 
-        def __new__(_cls, system: str, node: str, release: str, version: str, machine: str) -> Self: ...
-        @property
-        def processor(self) -> str: ...
-
-else:
-    # On 3.8, uname_result is actually just a regular NamedTuple.
-    class uname_result(NamedTuple):
-        system: str
-        node: str
-        release: str
-        version: str
-        machine: str
-        processor: str
+    def __new__(_cls, system: str, node: str, release: str, version: str, machine: str) -> Self: ...
+    @property
+    def processor(self) -> str: ...
 
 def uname() -> uname_result: ...
 def system() -> str: ...

stdlib/plistlib.pyi

@@ -3,12 +3,10 @@ from _typeshed import ReadableBuffer
 from collections.abc import Mapping, MutableMapping
 from datetime import datetime
 from enum import Enum
-from typing import IO, Any, ClassVar
+from typing import IO, Any
 from typing_extensions import Self
 
 __all__ = ["InvalidFileException", "FMT_XML", "FMT_BINARY", "load", "dump", "loads", "dumps", "UID"]
-if sys.version_info < (3, 9):
-    __all__ += ["readPlist", "writePlist", "readPlistFromBytes", "writePlistToBytes", "Data"]
 
 class PlistFormat(Enum):
     FMT_XML = 1
@@ -32,28 +30,12 @@ if sys.version_info >= (3, 13):
         aware_datetime: bool = False,
     ) -> Any: ...
 
-elif sys.version_info >= (3, 9):
+else:
     def load(fp: IO[bytes], *, fmt: PlistFormat | None = None, dict_type: type[MutableMapping[str, Any]] = ...) -> Any: ...
     def loads(
         value: ReadableBuffer, *, fmt: PlistFormat | None = None, dict_type: type[MutableMapping[str, Any]] = ...
     ) -> Any: ...
 
-else:
-    def load(
-        fp: IO[bytes],
-        *,
-        fmt: PlistFormat | None = None,
-        use_builtin_types: bool = True,
-        dict_type: type[MutableMapping[str, Any]] = ...,
-    ) -> Any: ...
-    def loads(
-        value: ReadableBuffer,
-        *,
-        fmt: PlistFormat | None = None,
-        use_builtin_types: bool = True,
-        dict_type: type[MutableMapping[str, Any]] = ...,
-    ) -> Any: ...
-
 if sys.version_info >= (3, 13):
     def dump(
         value: Mapping[str, Any] | list[Any] | tuple[Any, ...] | str | bool | float | bytes | bytearray | datetime,
@@ -90,18 +72,6 @@ else:
         sort_keys: bool = True,
     ) -> bytes: ...
 
-if sys.version_info < (3, 9):
-    def readPlist(pathOrFile: str | IO[bytes]) -> Any: ...
-    def writePlist(value: Mapping[str, Any], pathOrFile: str | IO[bytes]) -> None: ...
-    def readPlistFromBytes(data: ReadableBuffer) -> Any: ...
-    def writePlistToBytes(value: Mapping[str, Any]) -> bytes: ...
-
-if sys.version_info < (3, 9):
-    class Data:
-        data: bytes
-        def __init__(self, data: bytes) -> None: ...
-        __hash__: ClassVar[None]  # type: ignore[assignment]
-
 class UID:
     data: int
     def __init__(self, data: int) -> None: ...

stdlib/posix.pyi

@@ -6,6 +6,8 @@ if sys.platform != "win32":
         CLD_CONTINUED as CLD_CONTINUED,
         CLD_DUMPED as CLD_DUMPED,
         CLD_EXITED as CLD_EXITED,
+        CLD_KILLED as CLD_KILLED,
+        CLD_STOPPED as CLD_STOPPED,
         CLD_TRAPPED as CLD_TRAPPED,
         EX_CANTCREAT as EX_CANTCREAT,
         EX_CONFIG as EX_CONFIG,
@@ -220,13 +222,11 @@ if sys.platform != "win32":
         wait3 as wait3,
         wait4 as wait4,
         waitpid as waitpid,
+        waitstatus_to_exitcode as waitstatus_to_exitcode,
         write as write,
         writev as writev,
     )
 
-    if sys.version_info >= (3, 9):
-        from os import CLD_KILLED as CLD_KILLED, CLD_STOPPED as CLD_STOPPED, waitstatus_to_exitcode as waitstatus_to_exitcode
-
     if sys.version_info >= (3, 10):
         from os import O_FSYNC as O_FSYNC
 
@@ -330,6 +330,7 @@ if sys.platform != "win32":
             O_PATH as O_PATH,
             O_RSYNC as O_RSYNC,
             O_TMPFILE as O_TMPFILE,
+            P_PIDFD as P_PIDFD,
             RTLD_DEEPBIND as RTLD_DEEPBIND,
             SCHED_BATCH as SCHED_BATCH,
             SCHED_IDLE as SCHED_IDLE,
@@ -342,13 +343,11 @@ if sys.platform != "win32":
             getxattr as getxattr,
             listxattr as listxattr,
             memfd_create as memfd_create,
+            pidfd_open as pidfd_open,
             removexattr as removexattr,
             setxattr as setxattr,
         )
 
-        if sys.version_info >= (3, 9):
-            from os import P_PIDFD as P_PIDFD, pidfd_open as pidfd_open
-
         if sys.version_info >= (3, 10):
             from os import (
                 EFD_CLOEXEC as EFD_CLOEXEC,

stdlib/pstats.pyi

@@ -2,6 +2,7 @@ import sys
 from _typeshed import StrOrBytesPath
 from collections.abc import Iterable
 from cProfile import Profile as _cProfile
+from dataclasses import dataclass
 from profile import Profile
 from typing import IO, Any, Literal, overload
 from typing_extensions import Self, TypeAlias
@@ -11,10 +12,7 @@ if sys.version_info >= (3, 11):
 else:
     from enum import Enum
 
-if sys.version_info >= (3, 9):
-    __all__ = ["Stats", "SortKey", "FunctionProfile", "StatsProfile"]
-else:
-    __all__ = ["Stats", "SortKey"]
+__all__ = ["Stats", "SortKey", "FunctionProfile", "StatsProfile"]
 
 _Selector: TypeAlias = str | float | int
 
@@ -42,23 +40,20 @@ else:
         STDNAME = "stdname"
         TIME = "time"
 
-if sys.version_info >= (3, 9):
-    from dataclasses import dataclass
+@dataclass(unsafe_hash=True)
+class FunctionProfile:
+    ncalls: str
+    tottime: float
+    percall_tottime: float
+    cumtime: float
+    percall_cumtime: float
+    file_name: str
+    line_number: int
 
-    @dataclass(unsafe_hash=True)
-    class FunctionProfile:
-        ncalls: str
-        tottime: float
-        percall_tottime: float
-        cumtime: float
-        percall_cumtime: float
-        file_name: str
-        line_number: int
-
-    @dataclass(unsafe_hash=True)
-    class StatsProfile:
-        total_tt: float
-        func_profiles: dict[str, FunctionProfile]
+@dataclass(unsafe_hash=True)
+class StatsProfile:
+    total_tt: float
+    func_profiles: dict[str, FunctionProfile]
 
 _SortArgDict: TypeAlias = dict[str, tuple[tuple[tuple[int, int], ...], str]]
 
@@ -85,9 +80,7 @@ class Stats:
     def strip_dirs(self) -> Self: ...
     def calc_callees(self) -> None: ...
     def eval_print_amount(self, sel: _Selector, list: list[str], msg: str) -> tuple[list[str], str]: ...
-    if sys.version_info >= (3, 9):
-        def get_stats_profile(self) -> StatsProfile: ...
-
+    def get_stats_profile(self) -> StatsProfile: ...
     def get_print_list(self, sel_list: Iterable[_Selector]) -> tuple[int, list[str]]: ...
     def print_stats(self, *amount: _Selector) -> Self: ...
     def print_callees(self, *amount: _Selector) -> Self: ...

stdlib/queue.pyi

@@ -1,11 +1,9 @@
 import sys
 from _queue import Empty as Empty, SimpleQueue as SimpleQueue
 from threading import Condition, Lock
+from types import GenericAlias
 from typing import Any, Generic, TypeVar
 
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
-
 __all__ = ["Empty", "Full", "Queue", "PriorityQueue", "LifoQueue", "SimpleQueue"]
 if sys.version_info >= (3, 13):
     __all__ += ["ShutDown"]
@@ -47,8 +45,7 @@ class Queue(Generic[_T]):
     def qsize(self) -> int: ...
     def _qsize(self) -> int: ...
     def task_done(self) -> None: ...
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 class PriorityQueue(Queue[_T]):
     queue: list[_T]

stdlib/random.pyi

@@ -30,10 +30,9 @@ __all__ = [
     "getrandbits",
     "choices",
     "SystemRandom",
+    "randbytes",
 ]
 
-if sys.version_info >= (3, 9):
-    __all__ += ["randbytes"]
 if sys.version_info >= (3, 12):
     __all__ += ["binomialvariate"]
 
@@ -41,25 +40,16 @@ _T = TypeVar("_T")
 
 class Random(_random.Random):
     VERSION: ClassVar[int]
-    if sys.version_info >= (3, 9):
-        def __init__(self, x: int | float | str | bytes | bytearray | None = None) -> None: ...  # noqa: Y041
-    else:
-        def __init__(self, x: Any = None) -> None: ...
+    def __init__(self, x: int | float | str | bytes | bytearray | None = None) -> None: ...  # noqa: Y041
     # Using other `seed` types is deprecated since 3.9 and removed in 3.11
     # Ignore Y041, since random.seed doesn't treat int like a float subtype. Having an explicit
     # int better documents conventional usage of random.seed.
-    if sys.version_info >= (3, 9):
-        def seed(self, a: int | float | str | bytes | bytearray | None = None, version: int = 2) -> None: ...  # type: ignore[override]  # noqa: Y041
-    else:
-        def seed(self, a: Any = None, version: int = 2) -> None: ...
-
+    def seed(self, a: int | float | str | bytes | bytearray | None = None, version: int = 2) -> None: ...  # type: ignore[override]  # noqa: Y041
     def getstate(self) -> tuple[Any, ...]: ...
     def setstate(self, state: tuple[Any, ...]) -> None: ...
     def randrange(self, start: int, stop: int | None = None, step: int = 1) -> int: ...
     def randint(self, a: int, b: int) -> int: ...
-    if sys.version_info >= (3, 9):
-        def randbytes(self, n: int) -> bytes: ...
-
+    def randbytes(self, n: int) -> bytes: ...
     def choice(self, seq: SupportsLenAndGetItem[_T]) -> _T: ...
     def choices(
         self,
@@ -75,12 +65,10 @@ class Random(_random.Random):
         def shuffle(self, x: MutableSequence[Any], random: Callable[[], float] | None = None) -> None: ...
     if sys.version_info >= (3, 11):
         def sample(self, population: Sequence[_T], k: int, *, counts: Iterable[int] | None = None) -> list[_T]: ...
-    elif sys.version_info >= (3, 9):
+    else:
         def sample(
             self, population: Sequence[_T] | AbstractSet[_T], k: int, *, counts: Iterable[int] | None = None
         ) -> list[_T]: ...
-    else:
-        def sample(self, population: Sequence[_T] | AbstractSet[_T], k: int) -> list[_T]: ...
 
     def uniform(self, a: float, b: float) -> float: ...
     def triangular(self, low: float = 0.0, high: float = 1.0, mode: float | None = None) -> float: ...
@@ -137,5 +125,4 @@ weibullvariate = _inst.weibullvariate
 getstate = _inst.getstate
 setstate = _inst.setstate
 getrandbits = _inst.getrandbits
-if sys.version_info >= (3, 9):
-    randbytes = _inst.randbytes
+randbytes = _inst.randbytes

stdlib/re.pyi

@@ -4,12 +4,10 @@ import sre_constants
 import sys
 from _typeshed import MaybeNone, ReadableBuffer
 from collections.abc import Callable, Iterator, Mapping
+from types import GenericAlias
 from typing import Any, AnyStr, Final, Generic, Literal, TypeVar, final, overload
 from typing_extensions import TypeAlias
 
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
-
 __all__ = [
     "match",
     "fullmatch",
@@ -117,8 +115,7 @@ class Match(Generic[AnyStr]):
     def __getitem__(self, key: int | str, /) -> AnyStr | MaybeNone: ...
     def __copy__(self) -> Match[AnyStr]: ...
     def __deepcopy__(self, memo: Any, /) -> Match[AnyStr]: ...
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 @final
 class Pattern(Generic[AnyStr]):
@@ -197,8 +194,7 @@ class Pattern(Generic[AnyStr]):
     def __deepcopy__(self, memo: Any, /) -> Pattern[AnyStr]: ...
     def __eq__(self, value: object, /) -> bool: ...
     def __hash__(self) -> int: ...
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 # ----- re variables and constants -----
 

stdlib/signal.pyi

@@ -183,6 +183,5 @@ def valid_signals() -> set[Signals]: ...
 def raise_signal(signalnum: _SIGNUM, /) -> None: ...
 def set_wakeup_fd(fd: int, /, *, warn_on_full_buffer: bool = ...) -> int: ...
 
-if sys.version_info >= (3, 9):
-    if sys.platform == "linux":
-        def pidfd_send_signal(pidfd: int, sig: int, siginfo: None = None, flags: int = ..., /) -> None: ...
+if sys.platform == "linux":
+    def pidfd_send_signal(pidfd: int, sig: int, siginfo: None = None, flags: int = ..., /) -> None: ...

stdlib/smtplib.pyi

@@ -185,20 +185,11 @@ class SMTP_SSL(SMTP):
 LMTP_PORT: int
 
 class LMTP(SMTP):
-    if sys.version_info >= (3, 9):
-        def __init__(
-            self,
-            host: str = "",
-            port: int = 2003,
-            local_hostname: str | None = None,
-            source_address: _SourceAddress | None = None,
-            timeout: float = ...,
-        ) -> None: ...
-    else:
-        def __init__(
-            self,
-            host: str = "",
-            port: int = 2003,
-            local_hostname: str | None = None,
-            source_address: _SourceAddress | None = None,
-        ) -> None: ...
+    def __init__(
+        self,
+        host: str = "",
+        port: int = 2003,
+        local_hostname: str | None = None,
+        source_address: _SourceAddress | None = None,
+        timeout: float = ...,
+    ) -> None: ...

stdlib/socket.pyi

@@ -53,12 +53,18 @@ from _socket import (
     IPPROTO_TCP as IPPROTO_TCP,
     IPPROTO_UDP as IPPROTO_UDP,
     IPV6_CHECKSUM as IPV6_CHECKSUM,
+    IPV6_DONTFRAG as IPV6_DONTFRAG,
+    IPV6_HOPLIMIT as IPV6_HOPLIMIT,
+    IPV6_HOPOPTS as IPV6_HOPOPTS,
     IPV6_JOIN_GROUP as IPV6_JOIN_GROUP,
     IPV6_LEAVE_GROUP as IPV6_LEAVE_GROUP,
     IPV6_MULTICAST_HOPS as IPV6_MULTICAST_HOPS,
     IPV6_MULTICAST_IF as IPV6_MULTICAST_IF,
     IPV6_MULTICAST_LOOP as IPV6_MULTICAST_LOOP,
+    IPV6_PKTINFO as IPV6_PKTINFO,
+    IPV6_RECVRTHDR as IPV6_RECVRTHDR,
     IPV6_RECVTCLASS as IPV6_RECVTCLASS,
+    IPV6_RTHDR as IPV6_RTHDR,
     IPV6_TCLASS as IPV6_TCLASS,
     IPV6_UNICAST_HOPS as IPV6_UNICAST_HOPS,
     IPV6_V6ONLY as IPV6_V6ONLY,
@@ -195,12 +201,18 @@ __all__ = [
     "IPPROTO_TCP",
     "IPPROTO_UDP",
     "IPV6_CHECKSUM",
+    "IPV6_DONTFRAG",
+    "IPV6_HOPLIMIT",
+    "IPV6_HOPOPTS",
     "IPV6_JOIN_GROUP",
     "IPV6_LEAVE_GROUP",
     "IPV6_MULTICAST_HOPS",
     "IPV6_MULTICAST_IF",
     "IPV6_MULTICAST_LOOP",
+    "IPV6_PKTINFO",
+    "IPV6_RECVRTHDR",
     "IPV6_RECVTCLASS",
+    "IPV6_RTHDR",
     "IPV6_TCLASS",
     "IPV6_UNICAST_HOPS",
     "IPV6_V6ONLY",
@@ -335,18 +347,6 @@ if sys.platform == "win32":
         "MSG_MCAST",
     ]
 
-if sys.platform != "darwin" or sys.version_info >= (3, 9):
-    from _socket import (
-        IPV6_DONTFRAG as IPV6_DONTFRAG,
-        IPV6_HOPLIMIT as IPV6_HOPLIMIT,
-        IPV6_HOPOPTS as IPV6_HOPOPTS,
-        IPV6_PKTINFO as IPV6_PKTINFO,
-        IPV6_RECVRTHDR as IPV6_RECVRTHDR,
-        IPV6_RTHDR as IPV6_RTHDR,
-    )
-
-    __all__ += ["IPV6_DONTFRAG", "IPV6_HOPLIMIT", "IPV6_HOPOPTS", "IPV6_PKTINFO", "IPV6_RECVRTHDR", "IPV6_RTHDR"]
-
 if sys.platform == "darwin":
     from _socket import PF_SYSTEM as PF_SYSTEM, SYSPROTO_CONTROL as SYSPROTO_CONTROL
 
@@ -490,30 +490,29 @@ if sys.platform != "win32":
         "MSG_NOSIGNAL",
     ]
 
-    if sys.platform != "darwin" or sys.version_info >= (3, 9):
-        from _socket import (
-            IPV6_DSTOPTS as IPV6_DSTOPTS,
-            IPV6_NEXTHOP as IPV6_NEXTHOP,
-            IPV6_PATHMTU as IPV6_PATHMTU,
-            IPV6_RECVDSTOPTS as IPV6_RECVDSTOPTS,
-            IPV6_RECVHOPLIMIT as IPV6_RECVHOPLIMIT,
-            IPV6_RECVHOPOPTS as IPV6_RECVHOPOPTS,
-            IPV6_RECVPATHMTU as IPV6_RECVPATHMTU,
-            IPV6_RECVPKTINFO as IPV6_RECVPKTINFO,
-            IPV6_RTHDRDSTOPTS as IPV6_RTHDRDSTOPTS,
-        )
+    from _socket import (
+        IPV6_DSTOPTS as IPV6_DSTOPTS,
+        IPV6_NEXTHOP as IPV6_NEXTHOP,
+        IPV6_PATHMTU as IPV6_PATHMTU,
+        IPV6_RECVDSTOPTS as IPV6_RECVDSTOPTS,
+        IPV6_RECVHOPLIMIT as IPV6_RECVHOPLIMIT,
+        IPV6_RECVHOPOPTS as IPV6_RECVHOPOPTS,
+        IPV6_RECVPATHMTU as IPV6_RECVPATHMTU,
+        IPV6_RECVPKTINFO as IPV6_RECVPKTINFO,
+        IPV6_RTHDRDSTOPTS as IPV6_RTHDRDSTOPTS,
+    )
 
-        __all__ += [
-            "IPV6_DSTOPTS",
-            "IPV6_NEXTHOP",
-            "IPV6_PATHMTU",
-            "IPV6_RECVDSTOPTS",
-            "IPV6_RECVHOPLIMIT",
-            "IPV6_RECVHOPOPTS",
-            "IPV6_RECVPATHMTU",
-            "IPV6_RECVPKTINFO",
-            "IPV6_RTHDRDSTOPTS",
-        ]
+    __all__ += [
+        "IPV6_DSTOPTS",
+        "IPV6_NEXTHOP",
+        "IPV6_PATHMTU",
+        "IPV6_RECVDSTOPTS",
+        "IPV6_RECVHOPLIMIT",
+        "IPV6_RECVHOPOPTS",
+        "IPV6_RECVPATHMTU",
+        "IPV6_RECVPKTINFO",
+        "IPV6_RTHDRDSTOPTS",
+    ]
 
     if sys.platform != "darwin":
         from _socket import SO_BINDTODEVICE as SO_BINDTODEVICE
@@ -521,10 +520,9 @@ if sys.platform != "win32":
         __all__ += ["SO_BINDTODEVICE"]
 
 if sys.platform != "darwin" and sys.platform != "linux":
-    if sys.platform != "win32" or sys.version_info >= (3, 9):
-        from _socket import BDADDR_ANY as BDADDR_ANY, BDADDR_LOCAL as BDADDR_LOCAL, BTPROTO_RFCOMM as BTPROTO_RFCOMM
+    from _socket import BDADDR_ANY as BDADDR_ANY, BDADDR_LOCAL as BDADDR_LOCAL, BTPROTO_RFCOMM as BTPROTO_RFCOMM
 
-        __all__ += ["BDADDR_ANY", "BDADDR_LOCAL", "BTPROTO_RFCOMM"]
+    __all__ += ["BDADDR_ANY", "BDADDR_LOCAL", "BTPROTO_RFCOMM"]
 
 if sys.platform == "darwin" and sys.version_info >= (3, 10):
     from _socket import TCP_KEEPALIVE as TCP_KEEPALIVE
@@ -777,7 +775,7 @@ if sys.platform == "linux":
 
         __all__ += ["CAN_RAW_ERR_FILTER"]
 
-if sys.platform == "linux" and sys.version_info >= (3, 9):
+if sys.platform == "linux":
     from _socket import (
         CAN_J1939 as CAN_J1939,
         CAN_RAW_JOIN_FILTERS as CAN_RAW_JOIN_FILTERS,
@@ -959,14 +957,13 @@ if sys.version_info >= (3, 12):
 
         __all__ += ["PF_DIVERT", "AF_DIVERT"]
 
-if sys.platform != "win32" and sys.version_info >= (3, 9):
+if sys.platform != "win32":
     __all__ += ["send_fds", "recv_fds"]
 
-if sys.platform != "win32" or sys.version_info >= (3, 9):
-    if sys.platform != "linux":
-        __all__ += ["AF_LINK"]
-    if sys.platform != "darwin" and sys.platform != "linux":
-        __all__ += ["AF_BLUETOOTH"]
+if sys.platform != "linux":
+    __all__ += ["AF_LINK"]
+if sys.platform != "darwin" and sys.platform != "linux":
+    __all__ += ["AF_BLUETOOTH"]
 
 if sys.platform == "win32" and sys.version_info >= (3, 12):
     __all__ += ["AF_HYPERV"]
@@ -980,6 +977,7 @@ if sys.platform != "win32" and sys.platform != "linux":
         IPPROTO_HELLO as IPPROTO_HELLO,
         IPPROTO_IPCOMP as IPPROTO_IPCOMP,
         IPPROTO_XTP as IPPROTO_XTP,
+        IPV6_USE_MIN_MTU as IPV6_USE_MIN_MTU,
         LOCAL_PEERCRED as LOCAL_PEERCRED,
         SCM_CREDS as SCM_CREDS,
     )
@@ -992,6 +990,7 @@ if sys.platform != "win32" and sys.platform != "linux":
         "IPPROTO_HELLO",
         "IPPROTO_IPCOMP",
         "IPPROTO_XTP",
+        "IPV6_USE_MIN_MTU",
         "LOCAL_PEERCRED",
         "SCM_CREDS",
         "AI_DEFAULT",
@@ -999,10 +998,6 @@ if sys.platform != "win32" and sys.platform != "linux":
         "AI_V4MAPPED_CFG",
         "MSG_EOF",
     ]
-    if sys.platform != "darwin" or sys.version_info >= (3, 9):
-        from _socket import IPV6_USE_MIN_MTU as IPV6_USE_MIN_MTU
-
-        __all__ += ["IPV6_USE_MIN_MTU"]
 
 if sys.platform != "win32" and sys.platform != "darwin" and sys.platform != "linux":
     from _socket import (
@@ -1084,11 +1079,10 @@ class AddressFamily(IntEnum):
         AF_NETLINK = 16
         AF_VSOCK = 40
         AF_QIPCRTR = 42
-    if sys.platform != "win32" or sys.version_info >= (3, 9):
-        if sys.platform != "linux":
-            AF_LINK = 33
-        if sys.platform != "darwin" and sys.platform != "linux":
-            AF_BLUETOOTH = 32
+    if sys.platform != "linux":
+        AF_LINK = 33
+    if sys.platform != "darwin" and sys.platform != "linux":
+        AF_BLUETOOTH = 32
     if sys.platform == "win32" and sys.version_info >= (3, 12):
         AF_HYPERV = 34
     if sys.platform != "linux" and sys.platform != "win32" and sys.platform != "darwin" and sys.version_info >= (3, 12):
@@ -1140,12 +1134,10 @@ if sys.platform == "linux":
     AF_VSOCK = AddressFamily.AF_VSOCK
     AF_QIPCRTR = AddressFamily.AF_QIPCRTR
 
-if sys.platform != "win32" or sys.version_info >= (3, 9):
-    if sys.platform != "linux":
-        AF_LINK = AddressFamily.AF_LINK
-    if sys.platform != "darwin" and sys.platform != "linux":
-        AF_BLUETOOTH = AddressFamily.AF_BLUETOOTH
-
+if sys.platform != "linux":
+    AF_LINK = AddressFamily.AF_LINK
+if sys.platform != "darwin" and sys.platform != "linux":
+    AF_BLUETOOTH = AddressFamily.AF_BLUETOOTH
 if sys.platform == "win32" and sys.version_info >= (3, 12):
     AF_HYPERV = AddressFamily.AF_HYPERV
 if sys.platform != "linux" and sys.platform != "win32" and sys.platform != "darwin" and sys.version_info >= (3, 12):
@@ -1352,11 +1344,10 @@ class socket(_socket.socket):
 def fromfd(fd: SupportsIndex, family: AddressFamily | int, type: SocketKind | int, proto: int = 0) -> socket: ...
 
 if sys.platform != "win32":
-    if sys.version_info >= (3, 9):
-        def send_fds(
-            sock: socket, buffers: Iterable[ReadableBuffer], fds: Iterable[int], flags: Unused = 0, address: Unused = None
-        ) -> int: ...
-        def recv_fds(sock: socket, bufsize: int, maxfds: int, flags: int = 0) -> tuple[bytes, list[int], int, Any]: ...
+    def send_fds(
+        sock: socket, buffers: Iterable[ReadableBuffer], fds: Iterable[int], flags: Unused = 0, address: Unused = None
+    ) -> int: ...
+    def recv_fds(sock: socket, bufsize: int, maxfds: int, flags: int = 0) -> tuple[bytes, list[int], int, Any]: ...
 
 if sys.platform == "win32":
     def fromshare(info: bytes) -> socket: ...

stdlib/ssl.pyi

@@ -512,8 +512,6 @@ SSL_ERROR_ZERO_RETURN: SSLErrorNumber  # undocumented
 
 def get_protocol_name(protocol_code: int) -> str: ...
 
-if sys.version_info < (3, 9):
-    AF_INET: int
 PEM_FOOTER: str
 PEM_HEADER: str
 SOCK_STREAM: int

stdlib/statistics.pyi

@@ -98,9 +98,7 @@ class NormalDist:
     def inv_cdf(self, p: float) -> float: ...
     def overlap(self, other: NormalDist) -> float: ...
     def quantiles(self, n: int = 4) -> list[float]: ...
-    if sys.version_info >= (3, 9):
-        def zscore(self, x: float) -> float: ...
-
+    def zscore(self, x: float) -> float: ...
     def __eq__(x1, x2: object) -> bool: ...
     def __add__(x1, x2: float | NormalDist) -> NormalDist: ...
     def __sub__(x1, x2: float | NormalDist) -> NormalDist: ...

stdlib/string.pyi

@@ -3,7 +3,7 @@ from _typeshed import StrOrLiteralStr
 from collections.abc import Iterable, Mapping, Sequence
 from re import Pattern, RegexFlag
 from typing import Any, ClassVar, overload
-from typing_extensions import LiteralString, TypeAlias
+from typing_extensions import LiteralString
 
 __all__ = [
     "ascii_letters",
@@ -32,14 +32,7 @@ whitespace: LiteralString
 
 def capwords(s: StrOrLiteralStr, sep: StrOrLiteralStr | None = None) -> StrOrLiteralStr: ...
 
-if sys.version_info >= (3, 9):
-    _TemplateMetaclass: TypeAlias = type
-else:
-    class _TemplateMetaclass(type):
-        pattern: ClassVar[str]
-        def __init__(cls, name: str, bases: tuple[type, ...], dct: dict[str, Any]) -> None: ...
-
-class Template(metaclass=_TemplateMetaclass):
+class Template(metaclass=type):
     template: str
     delimiter: ClassVar[str]
     idpattern: ClassVar[str]

stdlib/subprocess.pyi

@@ -1,13 +1,10 @@
 import sys
 from _typeshed import MaybeNone, ReadableBuffer, StrOrBytesPath
 from collections.abc import Callable, Collection, Iterable, Mapping, Sequence
-from types import TracebackType
+from types import GenericAlias, TracebackType
 from typing import IO, Any, AnyStr, Final, Generic, Literal, TypeVar, overload
 from typing_extensions import Self, TypeAlias
 
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
-
 __all__ = [
     "Popen",
     "PIPE",
@@ -87,8 +84,7 @@ class CompletedProcess(Generic[_T]):
     stderr: _T
     def __init__(self, args: _CMD, returncode: int, stdout: _T | None = None, stderr: _T | None = None) -> None: ...
     def check_returncode(self) -> None: ...
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 if sys.version_info >= (3, 11):
     # 3.11 adds "process_group" argument
@@ -500,7 +496,7 @@ elif sys.version_info >= (3, 10):
         pipesize: int = -1,
     ) -> CompletedProcess[Any]: ...
 
-elif sys.version_info >= (3, 9):
+else:
     # 3.9 adds arguments "user", "group", "extra_groups" and "umask"
     @overload
     def run(
@@ -696,177 +692,6 @@ elif sys.version_info >= (3, 9):
         umask: int = -1,
     ) -> CompletedProcess[Any]: ...
 
-else:
-    @overload
-    def run(
-        args: _CMD,
-        bufsize: int = -1,
-        executable: StrOrBytesPath | None = None,
-        stdin: _FILE = None,
-        stdout: _FILE = None,
-        stderr: _FILE = None,
-        preexec_fn: Callable[[], Any] | None = None,
-        close_fds: bool = True,
-        shell: bool = False,
-        cwd: StrOrBytesPath | None = None,
-        env: _ENV | None = None,
-        universal_newlines: bool | None = None,
-        startupinfo: Any = None,
-        creationflags: int = 0,
-        restore_signals: bool = True,
-        start_new_session: bool = False,
-        pass_fds: Collection[int] = ...,
-        *,
-        capture_output: bool = False,
-        check: bool = False,
-        encoding: str | None = None,
-        errors: str | None = None,
-        input: str | None = None,
-        text: Literal[True],
-        timeout: float | None = None,
-    ) -> CompletedProcess[str]: ...
-    @overload
-    def run(
-        args: _CMD,
-        bufsize: int = -1,
-        executable: StrOrBytesPath | None = None,
-        stdin: _FILE = None,
-        stdout: _FILE = None,
-        stderr: _FILE = None,
-        preexec_fn: Callable[[], Any] | None = None,
-        close_fds: bool = True,
-        shell: bool = False,
-        cwd: StrOrBytesPath | None = None,
-        env: _ENV | None = None,
-        universal_newlines: bool | None = None,
-        startupinfo: Any = None,
-        creationflags: int = 0,
-        restore_signals: bool = True,
-        start_new_session: bool = False,
-        pass_fds: Collection[int] = ...,
-        *,
-        capture_output: bool = False,
-        check: bool = False,
-        encoding: str,
-        errors: str | None = None,
-        input: str | None = None,
-        text: bool | None = None,
-        timeout: float | None = None,
-    ) -> CompletedProcess[str]: ...
-    @overload
-    def run(
-        args: _CMD,
-        bufsize: int = -1,
-        executable: StrOrBytesPath | None = None,
-        stdin: _FILE = None,
-        stdout: _FILE = None,
-        stderr: _FILE = None,
-        preexec_fn: Callable[[], Any] | None = None,
-        close_fds: bool = True,
-        shell: bool = False,
-        cwd: StrOrBytesPath | None = None,
-        env: _ENV | None = None,
-        universal_newlines: bool | None = None,
-        startupinfo: Any = None,
-        creationflags: int = 0,
-        restore_signals: bool = True,
-        start_new_session: bool = False,
-        pass_fds: Collection[int] = ...,
-        *,
-        capture_output: bool = False,
-        check: bool = False,
-        encoding: str | None = None,
-        errors: str,
-        input: str | None = None,
-        text: bool | None = None,
-        timeout: float | None = None,
-    ) -> CompletedProcess[str]: ...
-    @overload
-    def run(
-        args: _CMD,
-        bufsize: int = -1,
-        executable: StrOrBytesPath | None = None,
-        stdin: _FILE = None,
-        stdout: _FILE = None,
-        stderr: _FILE = None,
-        preexec_fn: Callable[[], Any] | None = None,
-        close_fds: bool = True,
-        shell: bool = False,
-        cwd: StrOrBytesPath | None = None,
-        env: _ENV | None = None,
-        *,
-        universal_newlines: Literal[True],
-        startupinfo: Any = None,
-        creationflags: int = 0,
-        restore_signals: bool = True,
-        start_new_session: bool = False,
-        pass_fds: Collection[int] = ...,
-        # where the *real* keyword only args start
-        capture_output: bool = False,
-        check: bool = False,
-        encoding: str | None = None,
-        errors: str | None = None,
-        input: str | None = None,
-        text: bool | None = None,
-        timeout: float | None = None,
-    ) -> CompletedProcess[str]: ...
-    @overload
-    def run(
-        args: _CMD,
-        bufsize: int = -1,
-        executable: StrOrBytesPath | None = None,
-        stdin: _FILE = None,
-        stdout: _FILE = None,
-        stderr: _FILE = None,
-        preexec_fn: Callable[[], Any] | None = None,
-        close_fds: bool = True,
-        shell: bool = False,
-        cwd: StrOrBytesPath | None = None,
-        env: _ENV | None = None,
-        universal_newlines: Literal[False] | None = None,
-        startupinfo: Any = None,
-        creationflags: int = 0,
-        restore_signals: bool = True,
-        start_new_session: bool = False,
-        pass_fds: Collection[int] = ...,
-        *,
-        capture_output: bool = False,
-        check: bool = False,
-        encoding: None = None,
-        errors: None = None,
-        input: ReadableBuffer | None = None,
-        text: Literal[False] | None = None,
-        timeout: float | None = None,
-    ) -> CompletedProcess[bytes]: ...
-    @overload
-    def run(
-        args: _CMD,
-        bufsize: int = -1,
-        executable: StrOrBytesPath | None = None,
-        stdin: _FILE = None,
-        stdout: _FILE = None,
-        stderr: _FILE = None,
-        preexec_fn: Callable[[], Any] | None = None,
-        close_fds: bool = True,
-        shell: bool = False,
-        cwd: StrOrBytesPath | None = None,
-        env: _ENV | None = None,
-        universal_newlines: bool | None = None,
-        startupinfo: Any = None,
-        creationflags: int = 0,
-        restore_signals: bool = True,
-        start_new_session: bool = False,
-        pass_fds: Collection[int] = ...,
-        *,
-        capture_output: bool = False,
-        check: bool = False,
-        encoding: str | None = None,
-        errors: str | None = None,
-        input: _InputString | None = None,
-        text: bool | None = None,
-        timeout: float | None = None,
-    ) -> CompletedProcess[Any]: ...
-
 # Same args as Popen.__init__
 if sys.version_info >= (3, 11):
     # 3.11 adds "process_group" argument
@@ -931,8 +756,7 @@ elif sys.version_info >= (3, 10):
         pipesize: int = -1,
     ) -> int: ...
 
-elif sys.version_info >= (3, 9):
-    # 3.9 adds arguments "user", "group", "extra_groups" and "umask"
+else:
     def call(
         args: _CMD,
         bufsize: int = -1,
@@ -961,31 +785,6 @@ elif sys.version_info >= (3, 9):
         umask: int = -1,
     ) -> int: ...
 
-else:
-    def call(
-        args: _CMD,
-        bufsize: int = -1,
-        executable: StrOrBytesPath | None = None,
-        stdin: _FILE = None,
-        stdout: _FILE = None,
-        stderr: _FILE = None,
-        preexec_fn: Callable[[], Any] | None = None,
-        close_fds: bool = True,
-        shell: bool = False,
-        cwd: StrOrBytesPath | None = None,
-        env: _ENV | None = None,
-        universal_newlines: bool | None = None,
-        startupinfo: Any = None,
-        creationflags: int = 0,
-        restore_signals: bool = True,
-        start_new_session: bool = False,
-        pass_fds: Collection[int] = ...,
-        *,
-        encoding: str | None = None,
-        timeout: float | None = None,
-        text: bool | None = None,
-    ) -> int: ...
-
 # Same args as Popen.__init__
 if sys.version_info >= (3, 11):
     # 3.11 adds "process_group" argument
@@ -1050,8 +849,7 @@ elif sys.version_info >= (3, 10):
         pipesize: int = -1,
     ) -> int: ...
 
-elif sys.version_info >= (3, 9):
-    # 3.9 adds arguments "user", "group", "extra_groups" and "umask"
+else:
     def check_call(
         args: _CMD,
         bufsize: int = -1,
@@ -1080,31 +878,6 @@ elif sys.version_info >= (3, 9):
         umask: int = -1,
     ) -> int: ...
 
-else:
-    def check_call(
-        args: _CMD,
-        bufsize: int = -1,
-        executable: StrOrBytesPath | None = None,
-        stdin: _FILE = None,
-        stdout: _FILE = None,
-        stderr: _FILE = None,
-        preexec_fn: Callable[[], Any] | None = None,
-        close_fds: bool = True,
-        shell: bool = False,
-        cwd: StrOrBytesPath | None = None,
-        env: _ENV | None = None,
-        universal_newlines: bool | None = None,
-        startupinfo: Any = None,
-        creationflags: int = 0,
-        restore_signals: bool = True,
-        start_new_session: bool = False,
-        pass_fds: Collection[int] = ...,
-        timeout: float | None = ...,
-        *,
-        encoding: str | None = None,
-        text: bool | None = None,
-    ) -> int: ...
-
 if sys.version_info >= (3, 11):
     # 3.11 adds "process_group" argument
     @overload
@@ -1479,184 +1252,6 @@ elif sys.version_info >= (3, 10):
         pipesize: int = -1,
     ) -> Any: ...  # morally: -> str | bytes
 
-elif sys.version_info >= (3, 9):
-    # 3.9 adds arguments "user", "group", "extra_groups" and "umask"
-    @overload
-    def check_output(
-        args: _CMD,
-        bufsize: int = -1,
-        executable: StrOrBytesPath | None = None,
-        stdin: _FILE = None,
-        stderr: _FILE = None,
-        preexec_fn: Callable[[], Any] | None = None,
-        close_fds: bool = True,
-        shell: bool = False,
-        cwd: StrOrBytesPath | None = None,
-        env: _ENV | None = None,
-        universal_newlines: bool | None = None,
-        startupinfo: Any = None,
-        creationflags: int = 0,
-        restore_signals: bool = True,
-        start_new_session: bool = False,
-        pass_fds: Collection[int] = ...,
-        *,
-        timeout: float | None = None,
-        input: _InputString | None = ...,
-        encoding: str | None = None,
-        errors: str | None = None,
-        text: Literal[True],
-        user: str | int | None = None,
-        group: str | int | None = None,
-        extra_groups: Iterable[str | int] | None = None,
-        umask: int = -1,
-    ) -> str: ...
-    @overload
-    def check_output(
-        args: _CMD,
-        bufsize: int = -1,
-        executable: StrOrBytesPath | None = None,
-        stdin: _FILE = None,
-        stderr: _FILE = None,
-        preexec_fn: Callable[[], Any] | None = None,
-        close_fds: bool = True,
-        shell: bool = False,
-        cwd: StrOrBytesPath | None = None,
-        env: _ENV | None = None,
-        universal_newlines: bool | None = None,
-        startupinfo: Any = None,
-        creationflags: int = 0,
-        restore_signals: bool = True,
-        start_new_session: bool = False,
-        pass_fds: Collection[int] = ...,
-        *,
-        timeout: float | None = None,
-        input: _InputString | None = ...,
-        encoding: str,
-        errors: str | None = None,
-        text: bool | None = None,
-        user: str | int | None = None,
-        group: str | int | None = None,
-        extra_groups: Iterable[str | int] | None = None,
-        umask: int = -1,
-    ) -> str: ...
-    @overload
-    def check_output(
-        args: _CMD,
-        bufsize: int = -1,
-        executable: StrOrBytesPath | None = None,
-        stdin: _FILE = None,
-        stderr: _FILE = None,
-        preexec_fn: Callable[[], Any] | None = None,
-        close_fds: bool = True,
-        shell: bool = False,
-        cwd: StrOrBytesPath | None = None,
-        env: _ENV | None = None,
-        universal_newlines: bool | None = None,
-        startupinfo: Any = None,
-        creationflags: int = 0,
-        restore_signals: bool = True,
-        start_new_session: bool = False,
-        pass_fds: Collection[int] = ...,
-        *,
-        timeout: float | None = None,
-        input: _InputString | None = ...,
-        encoding: str | None = None,
-        errors: str,
-        text: bool | None = None,
-        user: str | int | None = None,
-        group: str | int | None = None,
-        extra_groups: Iterable[str | int] | None = None,
-        umask: int = -1,
-    ) -> str: ...
-    @overload
-    def check_output(
-        args: _CMD,
-        bufsize: int = -1,
-        executable: StrOrBytesPath | None = None,
-        stdin: _FILE = None,
-        stderr: _FILE = None,
-        preexec_fn: Callable[[], Any] | None = None,
-        close_fds: bool = True,
-        shell: bool = False,
-        cwd: StrOrBytesPath | None = None,
-        env: _ENV | None = None,
-        *,
-        universal_newlines: Literal[True],
-        startupinfo: Any = None,
-        creationflags: int = 0,
-        restore_signals: bool = True,
-        start_new_session: bool = False,
-        pass_fds: Collection[int] = ...,
-        # where the real keyword only ones start
-        timeout: float | None = None,
-        input: _InputString | None = ...,
-        encoding: str | None = None,
-        errors: str | None = None,
-        text: bool | None = None,
-        user: str | int | None = None,
-        group: str | int | None = None,
-        extra_groups: Iterable[str | int] | None = None,
-        umask: int = -1,
-    ) -> str: ...
-    @overload
-    def check_output(
-        args: _CMD,
-        bufsize: int = -1,
-        executable: StrOrBytesPath | None = None,
-        stdin: _FILE = None,
-        stderr: _FILE = None,
-        preexec_fn: Callable[[], Any] | None = None,
-        close_fds: bool = True,
-        shell: bool = False,
-        cwd: StrOrBytesPath | None = None,
-        env: _ENV | None = None,
-        universal_newlines: Literal[False] | None = None,
-        startupinfo: Any = None,
-        creationflags: int = 0,
-        restore_signals: bool = True,
-        start_new_session: bool = False,
-        pass_fds: Collection[int] = ...,
-        *,
-        timeout: float | None = None,
-        input: _InputString | None = ...,
-        encoding: None = None,
-        errors: None = None,
-        text: Literal[False] | None = None,
-        user: str | int | None = None,
-        group: str | int | None = None,
-        extra_groups: Iterable[str | int] | None = None,
-        umask: int = -1,
-    ) -> bytes: ...
-    @overload
-    def check_output(
-        args: _CMD,
-        bufsize: int = -1,
-        executable: StrOrBytesPath | None = None,
-        stdin: _FILE = None,
-        stderr: _FILE = None,
-        preexec_fn: Callable[[], Any] | None = None,
-        close_fds: bool = True,
-        shell: bool = False,
-        cwd: StrOrBytesPath | None = None,
-        env: _ENV | None = None,
-        universal_newlines: bool | None = None,
-        startupinfo: Any = None,
-        creationflags: int = 0,
-        restore_signals: bool = True,
-        start_new_session: bool = False,
-        pass_fds: Collection[int] = ...,
-        *,
-        timeout: float | None = None,
-        input: _InputString | None = ...,
-        encoding: str | None = None,
-        errors: str | None = None,
-        text: bool | None = None,
-        user: str | int | None = None,
-        group: str | int | None = None,
-        extra_groups: Iterable[str | int] | None = None,
-        umask: int = -1,
-    ) -> Any: ...  # morally: -> str | bytes
-
 else:
     @overload
     def check_output(
@@ -1682,6 +1277,10 @@ else:
         encoding: str | None = None,
         errors: str | None = None,
         text: Literal[True],
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
     ) -> str: ...
     @overload
     def check_output(
@@ -1707,6 +1306,10 @@ else:
         encoding: str,
         errors: str | None = None,
         text: bool | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
     ) -> str: ...
     @overload
     def check_output(
@@ -1732,6 +1335,10 @@ else:
         encoding: str | None = None,
         errors: str,
         text: bool | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
     ) -> str: ...
     @overload
     def check_output(
@@ -1758,6 +1365,10 @@ else:
         encoding: str | None = None,
         errors: str | None = None,
         text: bool | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
     ) -> str: ...
     @overload
     def check_output(
@@ -1783,6 +1394,10 @@ else:
         encoding: None = None,
         errors: None = None,
         text: Literal[False] | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
     ) -> bytes: ...
     @overload
     def check_output(
@@ -1808,6 +1423,10 @@ else:
         encoding: str | None = None,
         errors: str | None = None,
         text: bool | None = None,
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
     ) -> Any: ...  # morally: -> str | bytes
 
 PIPE: Final[int]
@@ -2223,183 +1842,6 @@ class Popen(Generic[AnyStr]):
             umask: int = -1,
             pipesize: int = -1,
         ) -> None: ...
-    elif sys.version_info >= (3, 9):
-        # user, group, extra_groups, umask were added in 3.9
-        @overload
-        def __init__(
-            self: Popen[str],
-            args: _CMD,
-            bufsize: int = -1,
-            executable: StrOrBytesPath | None = None,
-            stdin: _FILE | None = None,
-            stdout: _FILE | None = None,
-            stderr: _FILE | None = None,
-            preexec_fn: Callable[[], Any] | None = None,
-            close_fds: bool = True,
-            shell: bool = False,
-            cwd: StrOrBytesPath | None = None,
-            env: _ENV | None = None,
-            universal_newlines: bool | None = None,
-            startupinfo: Any | None = None,
-            creationflags: int = 0,
-            restore_signals: bool = True,
-            start_new_session: bool = False,
-            pass_fds: Collection[int] = (),
-            *,
-            text: bool | None = None,
-            encoding: str,
-            errors: str | None = None,
-            user: str | int | None = None,
-            group: str | int | None = None,
-            extra_groups: Iterable[str | int] | None = None,
-            umask: int = -1,
-        ) -> None: ...
-        @overload
-        def __init__(
-            self: Popen[str],
-            args: _CMD,
-            bufsize: int = -1,
-            executable: StrOrBytesPath | None = None,
-            stdin: _FILE | None = None,
-            stdout: _FILE | None = None,
-            stderr: _FILE | None = None,
-            preexec_fn: Callable[[], Any] | None = None,
-            close_fds: bool = True,
-            shell: bool = False,
-            cwd: StrOrBytesPath | None = None,
-            env: _ENV | None = None,
-            universal_newlines: bool | None = None,
-            startupinfo: Any | None = None,
-            creationflags: int = 0,
-            restore_signals: bool = True,
-            start_new_session: bool = False,
-            pass_fds: Collection[int] = (),
-            *,
-            text: bool | None = None,
-            encoding: str | None = None,
-            errors: str,
-            user: str | int | None = None,
-            group: str | int | None = None,
-            extra_groups: Iterable[str | int] | None = None,
-            umask: int = -1,
-        ) -> None: ...
-        @overload
-        def __init__(
-            self: Popen[str],
-            args: _CMD,
-            bufsize: int = -1,
-            executable: StrOrBytesPath | None = None,
-            stdin: _FILE | None = None,
-            stdout: _FILE | None = None,
-            stderr: _FILE | None = None,
-            preexec_fn: Callable[[], Any] | None = None,
-            close_fds: bool = True,
-            shell: bool = False,
-            cwd: StrOrBytesPath | None = None,
-            env: _ENV | None = None,
-            *,
-            universal_newlines: Literal[True],
-            startupinfo: Any | None = None,
-            creationflags: int = 0,
-            restore_signals: bool = True,
-            start_new_session: bool = False,
-            pass_fds: Collection[int] = (),
-            # where the *real* keyword only args start
-            text: bool | None = None,
-            encoding: str | None = None,
-            errors: str | None = None,
-            user: str | int | None = None,
-            group: str | int | None = None,
-            extra_groups: Iterable[str | int] | None = None,
-            umask: int = -1,
-        ) -> None: ...
-        @overload
-        def __init__(
-            self: Popen[str],
-            args: _CMD,
-            bufsize: int = -1,
-            executable: StrOrBytesPath | None = None,
-            stdin: _FILE | None = None,
-            stdout: _FILE | None = None,
-            stderr: _FILE | None = None,
-            preexec_fn: Callable[[], Any] | None = None,
-            close_fds: bool = True,
-            shell: bool = False,
-            cwd: StrOrBytesPath | None = None,
-            env: _ENV | None = None,
-            universal_newlines: bool | None = None,
-            startupinfo: Any | None = None,
-            creationflags: int = 0,
-            restore_signals: bool = True,
-            start_new_session: bool = False,
-            pass_fds: Collection[int] = (),
-            *,
-            text: Literal[True],
-            encoding: str | None = None,
-            errors: str | None = None,
-            user: str | int | None = None,
-            group: str | int | None = None,
-            extra_groups: Iterable[str | int] | None = None,
-            umask: int = -1,
-        ) -> None: ...
-        @overload
-        def __init__(
-            self: Popen[bytes],
-            args: _CMD,
-            bufsize: int = -1,
-            executable: StrOrBytesPath | None = None,
-            stdin: _FILE | None = None,
-            stdout: _FILE | None = None,
-            stderr: _FILE | None = None,
-            preexec_fn: Callable[[], Any] | None = None,
-            close_fds: bool = True,
-            shell: bool = False,
-            cwd: StrOrBytesPath | None = None,
-            env: _ENV | None = None,
-            universal_newlines: Literal[False] | None = None,
-            startupinfo: Any | None = None,
-            creationflags: int = 0,
-            restore_signals: bool = True,
-            start_new_session: bool = False,
-            pass_fds: Collection[int] = (),
-            *,
-            text: Literal[False] | None = None,
-            encoding: None = None,
-            errors: None = None,
-            user: str | int | None = None,
-            group: str | int | None = None,
-            extra_groups: Iterable[str | int] | None = None,
-            umask: int = -1,
-        ) -> None: ...
-        @overload
-        def __init__(
-            self: Popen[Any],
-            args: _CMD,
-            bufsize: int = -1,
-            executable: StrOrBytesPath | None = None,
-            stdin: _FILE | None = None,
-            stdout: _FILE | None = None,
-            stderr: _FILE | None = None,
-            preexec_fn: Callable[[], Any] | None = None,
-            close_fds: bool = True,
-            shell: bool = False,
-            cwd: StrOrBytesPath | None = None,
-            env: _ENV | None = None,
-            universal_newlines: bool | None = None,
-            startupinfo: Any | None = None,
-            creationflags: int = 0,
-            restore_signals: bool = True,
-            start_new_session: bool = False,
-            pass_fds: Collection[int] = (),
-            *,
-            text: bool | None = None,
-            encoding: str | None = None,
-            errors: str | None = None,
-            user: str | int | None = None,
-            group: str | int | None = None,
-            extra_groups: Iterable[str | int] | None = None,
-            umask: int = -1,
-        ) -> None: ...
     else:
         @overload
         def __init__(
@@ -2425,6 +1867,10 @@ class Popen(Generic[AnyStr]):
             text: bool | None = None,
             encoding: str,
             errors: str | None = None,
+            user: str | int | None = None,
+            group: str | int | None = None,
+            extra_groups: Iterable[str | int] | None = None,
+            umask: int = -1,
         ) -> None: ...
         @overload
         def __init__(
@@ -2450,6 +1896,10 @@ class Popen(Generic[AnyStr]):
             text: bool | None = None,
             encoding: str | None = None,
             errors: str,
+            user: str | int | None = None,
+            group: str | int | None = None,
+            extra_groups: Iterable[str | int] | None = None,
+            umask: int = -1,
         ) -> None: ...
         @overload
         def __init__(
@@ -2476,6 +1926,10 @@ class Popen(Generic[AnyStr]):
             text: bool | None = None,
             encoding: str | None = None,
             errors: str | None = None,
+            user: str | int | None = None,
+            group: str | int | None = None,
+            extra_groups: Iterable[str | int] | None = None,
+            umask: int = -1,
         ) -> None: ...
         @overload
         def __init__(
@@ -2501,6 +1955,10 @@ class Popen(Generic[AnyStr]):
             text: Literal[True],
             encoding: str | None = None,
             errors: str | None = None,
+            user: str | int | None = None,
+            group: str | int | None = None,
+            extra_groups: Iterable[str | int] | None = None,
+            umask: int = -1,
         ) -> None: ...
         @overload
         def __init__(
@@ -2526,6 +1984,10 @@ class Popen(Generic[AnyStr]):
             text: Literal[False] | None = None,
             encoding: None = None,
             errors: None = None,
+            user: str | int | None = None,
+            group: str | int | None = None,
+            extra_groups: Iterable[str | int] | None = None,
+            umask: int = -1,
         ) -> None: ...
         @overload
         def __init__(
@@ -2551,6 +2013,10 @@ class Popen(Generic[AnyStr]):
             text: bool | None = None,
             encoding: str | None = None,
             errors: str | None = None,
+            user: str | int | None = None,
+            group: str | int | None = None,
+            extra_groups: Iterable[str | int] | None = None,
+            umask: int = -1,
         ) -> None: ...
 
     def poll(self) -> int | None: ...
@@ -2567,8 +2033,7 @@ class Popen(Generic[AnyStr]):
         self, exc_type: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None
     ) -> None: ...
     def __del__(self) -> None: ...
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 # The result really is always a str.
 if sys.version_info >= (3, 11):

stdlib/sunau.pyi

@@ -1,4 +1,3 @@
-import sys
 from _typeshed import Unused
 from typing import IO, Any, Literal, NamedTuple, NoReturn, overload
 from typing_extensions import Self, TypeAlias
@@ -81,6 +80,3 @@ def open(f: _File, mode: Literal["r", "rb"]) -> Au_read: ...
 def open(f: _File, mode: Literal["w", "wb"]) -> Au_write: ...
 @overload
 def open(f: _File, mode: str | None = None) -> Any: ...
-
-if sys.version_info < (3, 9):
-    openfp = open

stdlib/symtable.pyi

@@ -36,9 +36,6 @@ class SymbolTable:
     def is_optimized(self) -> bool: ...
     def is_nested(self) -> bool: ...
     def has_children(self) -> bool: ...
-    if sys.version_info < (3, 9):
-        def has_exec(self) -> bool: ...
-
     def get_identifiers(self) -> dict_keys[str, int]: ...
     def lookup(self, name: str) -> Symbol: ...
     def get_symbols(self) -> list[Symbol]: ...
@@ -52,9 +49,8 @@ class Function(SymbolTable):
     def get_nonlocals(self) -> tuple[str, ...]: ...
 
 class Class(SymbolTable):
-    if sys.version_info < (3, 16):
-        @deprecated("deprecated in Python 3.14, will be removed in Python 3.16")
-        def get_methods(self) -> tuple[str, ...]: ...
+    @deprecated("deprecated in Python 3.14, will be removed in Python 3.16")
+    def get_methods(self) -> tuple[str, ...]: ...
 
 class Symbol:
     def __init__(

stdlib/tarfile.pyi

@@ -520,11 +520,7 @@ class TarFile:
 
 open = TarFile.open
 
-if sys.version_info >= (3, 9):
-    def is_tarfile(name: StrOrBytesPath | IO[bytes]) -> bool: ...
-
-else:
-    def is_tarfile(name: StrOrBytesPath) -> bool: ...
+def is_tarfile(name: StrOrBytesPath | IO[bytes]) -> bool: ...
 
 class TarError(Exception): ...
 class ReadError(TarError): ...

stdlib/tempfile.pyi

@@ -13,13 +13,10 @@ from _typeshed import (
     WriteableBuffer,
 )
 from collections.abc import Iterable, Iterator
-from types import TracebackType
+from types import GenericAlias, TracebackType
 from typing import IO, Any, AnyStr, Generic, Literal, overload
 from typing_extensions import Self
 
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
-
 __all__ = [
     "NamedTemporaryFile",
     "TemporaryFile",
@@ -399,8 +396,7 @@ class SpooledTemporaryFile(IO[AnyStr], _SpooledTemporaryFileBase):
     def seekable(self) -> bool: ...
     def writable(self) -> bool: ...
     def __next__(self) -> AnyStr: ...  # type: ignore[override]
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 class TemporaryDirectory(Generic[AnyStr]):
     name: AnyStr
@@ -458,8 +454,7 @@ class TemporaryDirectory(Generic[AnyStr]):
     def cleanup(self) -> None: ...
     def __enter__(self) -> AnyStr: ...
     def __exit__(self, exc: type[BaseException] | None, value: BaseException | None, tb: TracebackType | None) -> None: ...
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 # The overloads overlap, but they should still work fine.
 @overload

stdlib/threading.pyi

@@ -89,8 +89,6 @@ class Thread:
     @property
     def native_id(self) -> int | None: ...  # only available on some platforms
     def is_alive(self) -> bool: ...
-    if sys.version_info < (3, 9):
-        def isAlive(self) -> bool: ...
     # the following methods are all deprecated
     def getName(self) -> str: ...
     def setName(self, name: str) -> None: ...
@@ -134,10 +132,7 @@ class Semaphore:
     def __exit__(self, t: type[BaseException] | None, v: BaseException | None, tb: TracebackType | None) -> None: ...
     def acquire(self, blocking: bool = True, timeout: float | None = None) -> bool: ...
     def __enter__(self, blocking: bool = True, timeout: float | None = None) -> bool: ...
-    if sys.version_info >= (3, 9):
-        def release(self, n: int = 1) -> None: ...
-    else:
-        def release(self) -> None: ...
+    def release(self, n: int = 1) -> None: ...
 
 class BoundedSemaphore(Semaphore): ...
 

stdlib/time.pyi

@@ -31,7 +31,7 @@ if sys.platform == "darwin":
         CLOCK_UPTIME_RAW_APPROX: int
         CLOCK_MONOTONIC_RAW_APPROX: int
 
-if sys.version_info >= (3, 9) and sys.platform == "linux":
+if sys.platform == "linux":
     CLOCK_TAI: int
 
 # Constructor takes an iterable of any type, of length between 9 and 11 elements.

stdlib/tkinter/__init__.pyi

@@ -13,140 +13,139 @@ if sys.version_info >= (3, 11):
 else:
     from enum import Enum
 
-if sys.version_info >= (3, 9):
-    __all__ = [
-        "TclError",
-        "NO",
-        "FALSE",
-        "OFF",
-        "YES",
-        "TRUE",
-        "ON",
-        "N",
-        "S",
-        "W",
-        "E",
-        "NW",
-        "SW",
-        "NE",
-        "SE",
-        "NS",
-        "EW",
-        "NSEW",
-        "CENTER",
-        "NONE",
-        "X",
-        "Y",
-        "BOTH",
-        "LEFT",
-        "TOP",
-        "RIGHT",
-        "BOTTOM",
-        "RAISED",
-        "SUNKEN",
-        "FLAT",
-        "RIDGE",
-        "GROOVE",
-        "SOLID",
-        "HORIZONTAL",
-        "VERTICAL",
-        "NUMERIC",
-        "CHAR",
-        "WORD",
-        "BASELINE",
-        "INSIDE",
-        "OUTSIDE",
-        "SEL",
-        "SEL_FIRST",
-        "SEL_LAST",
-        "END",
-        "INSERT",
-        "CURRENT",
-        "ANCHOR",
-        "ALL",
-        "NORMAL",
-        "DISABLED",
-        "ACTIVE",
-        "HIDDEN",
-        "CASCADE",
-        "CHECKBUTTON",
-        "COMMAND",
-        "RADIOBUTTON",
-        "SEPARATOR",
-        "SINGLE",
-        "BROWSE",
-        "MULTIPLE",
-        "EXTENDED",
-        "DOTBOX",
-        "UNDERLINE",
-        "PIESLICE",
-        "CHORD",
-        "ARC",
-        "FIRST",
-        "LAST",
-        "BUTT",
-        "PROJECTING",
-        "ROUND",
-        "BEVEL",
-        "MITER",
-        "MOVETO",
-        "SCROLL",
-        "UNITS",
-        "PAGES",
-        "TkVersion",
-        "TclVersion",
-        "READABLE",
-        "WRITABLE",
-        "EXCEPTION",
-        "EventType",
-        "Event",
-        "NoDefaultRoot",
-        "Variable",
-        "StringVar",
-        "IntVar",
-        "DoubleVar",
-        "BooleanVar",
-        "mainloop",
-        "getint",
-        "getdouble",
-        "getboolean",
-        "Misc",
-        "CallWrapper",
-        "XView",
-        "YView",
-        "Wm",
-        "Tk",
-        "Tcl",
-        "Pack",
-        "Place",
-        "Grid",
-        "BaseWidget",
-        "Widget",
-        "Toplevel",
-        "Button",
-        "Canvas",
-        "Checkbutton",
-        "Entry",
-        "Frame",
-        "Label",
-        "Listbox",
-        "Menu",
-        "Menubutton",
-        "Message",
-        "Radiobutton",
-        "Scale",
-        "Scrollbar",
-        "Text",
-        "OptionMenu",
-        "Image",
-        "PhotoImage",
-        "BitmapImage",
-        "image_names",
-        "image_types",
-        "Spinbox",
-        "LabelFrame",
-        "PanedWindow",
-    ]
+__all__ = [
+    "TclError",
+    "NO",
+    "FALSE",
+    "OFF",
+    "YES",
+    "TRUE",
+    "ON",
+    "N",
+    "S",
+    "W",
+    "E",
+    "NW",
+    "SW",
+    "NE",
+    "SE",
+    "NS",
+    "EW",
+    "NSEW",
+    "CENTER",
+    "NONE",
+    "X",
+    "Y",
+    "BOTH",
+    "LEFT",
+    "TOP",
+    "RIGHT",
+    "BOTTOM",
+    "RAISED",
+    "SUNKEN",
+    "FLAT",
+    "RIDGE",
+    "GROOVE",
+    "SOLID",
+    "HORIZONTAL",
+    "VERTICAL",
+    "NUMERIC",
+    "CHAR",
+    "WORD",
+    "BASELINE",
+    "INSIDE",
+    "OUTSIDE",
+    "SEL",
+    "SEL_FIRST",
+    "SEL_LAST",
+    "END",
+    "INSERT",
+    "CURRENT",
+    "ANCHOR",
+    "ALL",
+    "NORMAL",
+    "DISABLED",
+    "ACTIVE",
+    "HIDDEN",
+    "CASCADE",
+    "CHECKBUTTON",
+    "COMMAND",
+    "RADIOBUTTON",
+    "SEPARATOR",
+    "SINGLE",
+    "BROWSE",
+    "MULTIPLE",
+    "EXTENDED",
+    "DOTBOX",
+    "UNDERLINE",
+    "PIESLICE",
+    "CHORD",
+    "ARC",
+    "FIRST",
+    "LAST",
+    "BUTT",
+    "PROJECTING",
+    "ROUND",
+    "BEVEL",
+    "MITER",
+    "MOVETO",
+    "SCROLL",
+    "UNITS",
+    "PAGES",
+    "TkVersion",
+    "TclVersion",
+    "READABLE",
+    "WRITABLE",
+    "EXCEPTION",
+    "EventType",
+    "Event",
+    "NoDefaultRoot",
+    "Variable",
+    "StringVar",
+    "IntVar",
+    "DoubleVar",
+    "BooleanVar",
+    "mainloop",
+    "getint",
+    "getdouble",
+    "getboolean",
+    "Misc",
+    "CallWrapper",
+    "XView",
+    "YView",
+    "Wm",
+    "Tk",
+    "Tcl",
+    "Pack",
+    "Place",
+    "Grid",
+    "BaseWidget",
+    "Widget",
+    "Toplevel",
+    "Button",
+    "Canvas",
+    "Checkbutton",
+    "Entry",
+    "Frame",
+    "Label",
+    "Listbox",
+    "Menu",
+    "Menubutton",
+    "Message",
+    "Radiobutton",
+    "Scale",
+    "Scrollbar",
+    "Text",
+    "OptionMenu",
+    "Image",
+    "PhotoImage",
+    "BitmapImage",
+    "image_names",
+    "image_types",
+    "Spinbox",
+    "LabelFrame",
+    "PanedWindow",
+]
 
 # Using anything from tkinter.font in this file means that 'import tkinter'
 # seems to also load tkinter.font. That's not how it actually works, but

stdlib/tkinter/colorchooser.pyi

@@ -1,20 +1,12 @@
-import sys
 from tkinter import Misc
 from tkinter.commondialog import Dialog
 from typing import ClassVar
 
-if sys.version_info >= (3, 9):
-    __all__ = ["Chooser", "askcolor"]
+__all__ = ["Chooser", "askcolor"]
 
 class Chooser(Dialog):
     command: ClassVar[str]
 
-if sys.version_info >= (3, 9):
-    def askcolor(
-        color: str | bytes | None = None, *, initialcolor: str = ..., parent: Misc = ..., title: str = ...
-    ) -> tuple[None, None] | tuple[tuple[int, int, int], str]: ...
-
-else:
-    def askcolor(
-        color: str | bytes | None = None, *, initialcolor: str = ..., parent: Misc = ..., title: str = ...
-    ) -> tuple[None, None] | tuple[tuple[float, float, float], str]: ...
+def askcolor(
+    color: str | bytes | None = None, *, initialcolor: str = ..., parent: Misc = ..., title: str = ...
+) -> tuple[None, None] | tuple[tuple[int, int, int], str]: ...

stdlib/tkinter/commondialog.pyi

@@ -1,10 +1,8 @@
-import sys
 from _typeshed import Incomplete
 from collections.abc import Mapping
 from typing import ClassVar
 
-if sys.version_info >= (3, 9):
-    __all__ = ["Dialog"]
+__all__ = ["Dialog"]
 
 class Dialog:
     command: ClassVar[str | None]

stdlib/tkinter/dialog.pyi

@@ -1,11 +1,9 @@
-import sys
 from _typeshed import Incomplete
 from collections.abc import Mapping
 from tkinter import Widget
 from typing import Any, Final
 
-if sys.version_info >= (3, 9):
-    __all__ = ["Dialog"]
+__all__ = ["Dialog"]
 
 DIALOG_ICON: Final = "questhead"
 

stdlib/tkinter/dnd.pyi

@@ -1,9 +1,7 @@
-import sys
 from tkinter import Event, Misc, Tk, Widget
 from typing import ClassVar, Protocol
 
-if sys.version_info >= (3, 9):
-    __all__ = ["dnd_start", "DndHandler"]
+__all__ = ["dnd_start", "DndHandler"]
 
 class _DndSource(Protocol):
     def dnd_end(self, target: Widget | None, event: Event[Misc] | None, /) -> None: ...

stdlib/tkinter/filedialog.pyi

@@ -1,25 +1,23 @@
-import sys
 from _typeshed import Incomplete, StrOrBytesPath
 from collections.abc import Iterable
 from tkinter import Button, Entry, Frame, Listbox, Misc, Scrollbar, StringVar, Toplevel, commondialog
 from typing import IO, ClassVar, Literal
 
-if sys.version_info >= (3, 9):
-    __all__ = [
-        "FileDialog",
-        "LoadFileDialog",
-        "SaveFileDialog",
-        "Open",
-        "SaveAs",
-        "Directory",
-        "askopenfilename",
-        "asksaveasfilename",
-        "askopenfilenames",
-        "askopenfile",
-        "askopenfiles",
-        "asksaveasfile",
-        "askdirectory",
-    ]
+__all__ = [
+    "FileDialog",
+    "LoadFileDialog",
+    "SaveFileDialog",
+    "Open",
+    "SaveAs",
+    "Directory",
+    "askopenfilename",
+    "asksaveasfilename",
+    "askopenfilenames",
+    "askopenfile",
+    "askopenfiles",
+    "asksaveasfile",
+    "askdirectory",
+]
 
 dialogstates: dict[Incomplete, tuple[Incomplete, Incomplete]]
 

stdlib/tkinter/font.pyi

@@ -5,8 +5,7 @@ import tkinter
 from typing import Any, ClassVar, Final, Literal, TypedDict, overload
 from typing_extensions import TypeAlias, Unpack
 
-if sys.version_info >= (3, 9):
-    __all__ = ["NORMAL", "ROMAN", "BOLD", "ITALIC", "nametofont", "Font", "families", "names"]
+__all__ = ["NORMAL", "ROMAN", "BOLD", "ITALIC", "nametofont", "Font", "families", "names"]
 
 NORMAL: Final = "normal"
 ROMAN: Final = "roman"

stdlib/tkinter/messagebox.pyi

@@ -1,18 +1,7 @@
-import sys
 from tkinter.commondialog import Dialog
 from typing import ClassVar, Final
 
-if sys.version_info >= (3, 9):
-    __all__ = [
-        "showinfo",
-        "showwarning",
-        "showerror",
-        "askquestion",
-        "askokcancel",
-        "askyesno",
-        "askyesnocancel",
-        "askretrycancel",
-    ]
+__all__ = ["showinfo", "showwarning", "showerror", "askquestion", "askokcancel", "askyesno", "askyesnocancel", "askretrycancel"]
 
 ERROR: Final = "error"
 INFO: Final = "info"