Move Match and Pattern to re.pyi; move ContextManager protocols to contextlib.pyi (#8447)

stdlib/re.pyi

@@ -2,10 +2,13 @@ import enum
 import sre_compile
 import sys
 from _typeshed import ReadableBuffer
-from collections.abc import Callable, Iterator
+from collections.abc import Callable, Iterator, Mapping
 from sre_constants import error as error
-from typing import Any, AnyStr, Match as Match, Pattern as Pattern, overload
-from typing_extensions import TypeAlias
+from typing import Any, AnyStr, Generic, TypeVar, overload
+from typing_extensions import Literal, TypeAlias, final
+
+if sys.version_info >= (3, 9):
+    from types import GenericAlias
 
 __all__ = [
     "match",
@@ -42,6 +45,121 @@ __all__ = [
 if sys.version_info >= (3, 11):
     __all__ += ["NOFLAG", "RegexFlag"]
 
+_T = TypeVar("_T")
+
+@final
+class Match(Generic[AnyStr]):
+    @property
+    def pos(self) -> int: ...
+    @property
+    def endpos(self) -> int: ...
+    @property
+    def lastindex(self) -> int | None: ...
+    @property
+    def lastgroup(self) -> str | None: ...
+    @property
+    def string(self) -> AnyStr: ...
+
+    # The regular expression object whose match() or search() method produced
+    # this match instance.
+    @property
+    def re(self) -> Pattern[AnyStr]: ...
+    @overload
+    def expand(self: Match[str], template: str) -> str: ...
+    @overload
+    def expand(self: Match[bytes], template: ReadableBuffer) -> bytes: ...
+    # group() returns "AnyStr" or "AnyStr | None", depending on the pattern.
+    @overload
+    def group(self, __group: Literal[0] = ...) -> AnyStr: ...
+    @overload
+    def group(self, __group: str | int) -> AnyStr | Any: ...
+    @overload
+    def group(self, __group1: str | int, __group2: str | int, *groups: str | int) -> tuple[AnyStr | Any, ...]: ...
+    # Each item of groups()'s return tuple is either "AnyStr" or
+    # "AnyStr | None", depending on the pattern.
+    @overload
+    def groups(self) -> tuple[AnyStr | Any, ...]: ...
+    @overload
+    def groups(self, default: _T) -> tuple[AnyStr | _T, ...]: ...
+    # Each value in groupdict()'s return dict is either "AnyStr" or
+    # "AnyStr | None", depending on the pattern.
+    @overload
+    def groupdict(self) -> dict[str, AnyStr | Any]: ...
+    @overload
+    def groupdict(self, default: _T) -> dict[str, AnyStr | _T]: ...
+    def start(self, __group: int | str = ...) -> int: ...
+    def end(self, __group: int | str = ...) -> int: ...
+    def span(self, __group: int | str = ...) -> tuple[int, int]: ...
+    @property
+    def regs(self) -> tuple[tuple[int, int], ...]: ...  # undocumented
+    # __getitem__() returns "AnyStr" or "AnyStr | None", depending on the pattern.
+    @overload
+    def __getitem__(self, __key: Literal[0]) -> AnyStr: ...
+    @overload
+    def __getitem__(self, __key: int | str) -> AnyStr | Any: ...
+    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: ...
+
+@final
+class Pattern(Generic[AnyStr]):
+    @property
+    def flags(self) -> int: ...
+    @property
+    def groupindex(self) -> Mapping[str, int]: ...
+    @property
+    def groups(self) -> int: ...
+    @property
+    def pattern(self) -> AnyStr: ...
+    @overload
+    def search(self: Pattern[str], string: str, pos: int = ..., endpos: int = ...) -> Match[str] | None: ...
+    @overload
+    def search(self: Pattern[bytes], string: ReadableBuffer, pos: int = ..., endpos: int = ...) -> Match[bytes] | None: ...
+    @overload
+    def match(self: Pattern[str], string: str, pos: int = ..., endpos: int = ...) -> Match[str] | None: ...
+    @overload
+    def match(self: Pattern[bytes], string: ReadableBuffer, pos: int = ..., endpos: int = ...) -> Match[bytes] | None: ...
+    @overload
+    def fullmatch(self: Pattern[str], string: str, pos: int = ..., endpos: int = ...) -> Match[str] | None: ...
+    @overload
+    def fullmatch(self: Pattern[bytes], string: ReadableBuffer, pos: int = ..., endpos: int = ...) -> Match[bytes] | None: ...
+    @overload
+    def split(self: Pattern[str], string: str, maxsplit: int = ...) -> list[str | Any]: ...
+    @overload
+    def split(self: Pattern[bytes], string: ReadableBuffer, maxsplit: int = ...) -> list[bytes | Any]: ...
+    # return type depends on the number of groups in the pattern
+    @overload
+    def findall(self: Pattern[str], string: str, pos: int = ..., endpos: int = ...) -> list[Any]: ...
+    @overload
+    def findall(self: Pattern[bytes], string: ReadableBuffer, pos: int = ..., endpos: int = ...) -> list[Any]: ...
+    @overload
+    def finditer(self: Pattern[str], string: str, pos: int = ..., endpos: int = ...) -> Iterator[Match[str]]: ...
+    @overload
+    def finditer(self: Pattern[bytes], string: ReadableBuffer, pos: int = ..., endpos: int = ...) -> Iterator[Match[bytes]]: ...
+    @overload
+    def sub(self: Pattern[str], repl: str | Callable[[Match[str]], str], string: str, count: int = ...) -> str: ...
+    @overload
+    def sub(
+        self: Pattern[bytes],
+        repl: ReadableBuffer | Callable[[Match[bytes]], ReadableBuffer],
+        string: ReadableBuffer,
+        count: int = ...,
+    ) -> bytes: ...
+    @overload
+    def subn(self: Pattern[str], repl: str | Callable[[Match[str]], str], string: str, count: int = ...) -> tuple[str, int]: ...
+    @overload
+    def subn(
+        self: Pattern[bytes],
+        repl: ReadableBuffer | Callable[[Match[bytes]], ReadableBuffer],
+        string: ReadableBuffer,
+        count: int = ...,
+    ) -> tuple[bytes, int]: ...
+    def __copy__(self) -> Pattern[AnyStr]: ...
+    def __deepcopy__(self, __memo: Any) -> Pattern[AnyStr]: ...
+    if sys.version_info >= (3, 9):
+        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+
 # ----- re variables and constants -----
 
 class RegexFlag(enum.IntFlag):