Add regex stubs

stubs/regex/@tests/stubtest_allowlist.txt

@@ -0,0 +1,7 @@
+# These classes are defined in regex/_regex.c and are returned by the public API functions.
+# The stubs are defined in regex/_regex.pyi but these classes aren't present at runtime,
+# so therefore we exclude them from the stubtest.
+regex._regex.Match
+regex._regex.Pattern
+regex._regex.Scanner
+regex._regex.Splitter

stubs/regex/METADATA.toml

@@ -0,0 +1 @@
+version = "2021.11.10"

stubs/regex/regex/__init__.pyi

@@ -0,0 +1 @@
+from .regex import *

stubs/regex/regex/_regex.pyi

@@ -0,0 +1,185 @@
+from _typeshed import Self
+from typing import Any, AnyStr, Callable, Generic, Mapping, TypeVar, overload
+
+_T = TypeVar("_T")
+
+class Pattern(Generic[AnyStr]):
+
+    pattern: AnyStr
+    flags: int
+    groups: int
+    groupindex: Mapping[str, int]
+    named_lists: Mapping[str, frozenset[AnyStr]]
+    def search(
+        self,
+        string: AnyStr,
+        pos: int | None = ...,
+        endpos: int | None = ...,
+        concurrent: bool | None = ...,
+        timeout: int | None = ...,
+    ) -> Match[AnyStr] | None: ...
+    def match(
+        self,
+        string: AnyStr,
+        pos: int | None = ...,
+        endpos: int | None = ...,
+        concurrent: bool | None = ...,
+        timeout: int | None = ...,
+    ) -> Match[AnyStr] | None: ...
+    def fullmatch(
+        self,
+        string: AnyStr,
+        pos: int | None = ...,
+        endpos: int | None = ...,
+        concurrent: bool | None = ...,
+        timeout: int | None = ...,
+    ) -> Match[AnyStr] | None: ...
+    def split(
+        self, string: AnyStr, maxsplit: int = ..., concurrent: bool | None = ..., timeout: int | None = ...
+    ) -> list[AnyStr | Any]: ...
+    def splititer(
+        self, string: AnyStr, maxsplit: int = ..., concurrent: bool | None = ..., timeout: int | None = ...
+    ) -> Splitter[AnyStr]: ...
+    def findall(
+        self,
+        string: AnyStr,
+        pos: int | None = ...,
+        endpos: int | None = ...,
+        overlapped: bool = ...,
+        concurrent: bool | None = ...,
+        timeout: int | None = ...,
+    ) -> list[Any]: ...
+    def finditer(
+        self,
+        string: AnyStr,
+        pos: int | None = ...,
+        endpos: int | None = ...,
+        overlapped: bool = ...,
+        concurrent: bool | None = ...,
+        timeout: int | None = ...,
+    ) -> Scanner[AnyStr]: ...
+    def sub(
+        self,
+        repl: AnyStr | Callable[[Match[AnyStr]], AnyStr],
+        string: AnyStr,
+        count: int = ...,
+        flags: int = ...,
+        pos: int | None = ...,
+        endpos: int | None = ...,
+        concurrent: bool | None = ...,
+        timeout: int | None = ...,
+    ) -> AnyStr: ...
+    def subf(
+        self,
+        format: AnyStr | Callable[[Match[AnyStr]], AnyStr],
+        string: AnyStr,
+        count: int = ...,
+        flags: int = ...,
+        pos: int | None = ...,
+        endpos: int | None = ...,
+        concurrent: bool | None = ...,
+        timeout: int | None = ...,
+    ) -> AnyStr: ...
+    def subn(
+        self,
+        repl: AnyStr | Callable[[Match[AnyStr]], AnyStr],
+        string: AnyStr,
+        count: int = ...,
+        flags: int = ...,
+        pos: int | None = ...,
+        endpos: int | None = ...,
+        concurrent: bool | None = ...,
+        timeout: int | None = ...,
+    ) -> tuple[AnyStr, int]: ...
+    def subfn(
+        self,
+        format: AnyStr | Callable[[Match[AnyStr]], AnyStr],
+        string: AnyStr,
+        count: int = ...,
+        flags: int = ...,
+        pos: int | None = ...,
+        endpos: int | None = ...,
+        concurrent: bool | None = ...,
+        timeout: int | None = ...,
+    ) -> tuple[AnyStr, int]: ...
+    def scanner(
+        self,
+        string: AnyStr,
+        pos: int | None = ...,
+        endpos: int | None = ...,
+        overlapped: bool = ...,
+        concurrent: bool | None = ...,
+        timeout: int | None = ...,
+    ) -> Scanner[AnyStr]: ...
+
+class Match(Generic[AnyStr]):
+
+    re: Pattern[AnyStr]
+    string: AnyStr
+    pos: int
+    endpos: int
+    partial: bool
+    regs: tuple[tuple[int, int], ...]
+    fuzzy_counts: tuple[int, int, int]
+    fuzzy_changes: tuple[list[int], list[int], list[int]]
+    lastgroup: str | None
+    lastindex: int | None
+    @overload
+    def group(self, __group: int | str = ...) -> AnyStr | Any: ...
+    @overload
+    def group(self, __group1: int | str, __group2: int | str, *groups: int | str) -> tuple[AnyStr | Any, ...]: ...
+    @overload
+    def groups(self, default: None = ...) -> tuple[AnyStr | Any, ...]: ...
+    @overload
+    def groups(self, default: _T) -> tuple[AnyStr | _T, ...]: ...
+    @overload
+    def groupdict(self, default: None = ...) -> dict[str, AnyStr | Any]: ...
+    @overload
+    def groupdict(self, default: _T) -> dict[str, AnyStr | _T]: ...
+    @overload
+    def span(self, __group: int | str = ...) -> tuple[int, int]: ...
+    @overload
+    def span(self, __group1: int | str, __group2: int | str, *groups: int | str) -> tuple[tuple[int, int], ...]: ...
+    @overload
+    def spans(self, __group: int | str = ...) -> list[tuple[int, int]]: ...
+    @overload
+    def spans(self, __group1: int | str, __group2: int | str, *groups: int | str) -> tuple[list[tuple[int, int]], ...]: ...
+    @overload
+    def start(self, __group: int | str = ...) -> int: ...
+    @overload
+    def start(self, __group1: int | str, __group2: int | str, *groups: int | str) -> tuple[int, ...]: ...
+    @overload
+    def starts(self, __group: int | str = ...) -> list[int]: ...
+    @overload
+    def starts(self, __group1: int | str, __group2: int | str, *groups: int | str) -> tuple[list[int], ...]: ...
+    @overload
+    def end(self, __group: int | str = ...) -> int: ...
+    @overload
+    def end(self, __group1: int | str, __group2: int | str, *groups: int | str) -> tuple[int, ...]: ...
+    @overload
+    def ends(self, __group: int | str = ...) -> list[int]: ...
+    @overload
+    def ends(self, __group1: int | str, __group2: int | str, *groups: int | str) -> tuple[list[int], ...]: ...
+    def expand(self, template: AnyStr) -> AnyStr: ...
+    def expandf(self, format: AnyStr) -> AnyStr: ...
+    @overload
+    def captures(self, __group: int | str = ...) -> list[AnyStr]: ...
+    @overload
+    def captures(self, __group1: int | str, __group2: int | str, *groups: int | str) -> tuple[list[AnyStr], ...]: ...
+    def capturesdict(self) -> dict[str, list[AnyStr]]: ...
+    def detach_string(self) -> None: ...
+
+class Splitter(Generic[AnyStr]):
+
+    pattern: Pattern[AnyStr]
+    def __iter__(self: Self) -> Self: ...
+    def __next__(self) -> AnyStr | Any: ...
+    def split(self) -> AnyStr | Any: ...
+
+class Scanner(Generic[AnyStr]):
+
+    pattern: Pattern[AnyStr]
+    def __iter__(self: Self) -> Self: ...
+    def __next__(self) -> Match[AnyStr]: ...
+    def match(self) -> Match[AnyStr] | None: ...
+    def search(self) -> Match[AnyStr] | None: ...

stubs/regex/regex/_regex_core.pyi

@@ -0,0 +1,41 @@
+from typing import AnyStr
+
+class error(Exception):
+    def __init__(self, message: str, pattern: AnyStr | None = ..., pos: int | None = ...) -> None: ...
+
+A: int
+ASCII: int
+B: int
+BESTMATCH: int
+D: int
+DEBUG: int
+E: int
+ENHANCEMATCH: int
+F: int
+FULLCASE: int
+I: int
+IGNORECASE: int
+L: int
+LOCALE: int
+M: int
+MULTILINE: int
+P: int
+POSIX: int
+R: int
+REVERSE: int
+T: int
+TEMPLATE: int
+S: int
+DOTALL: int
+U: int
+UNICODE: int
+V0: int
+VERSION0: int
+V1: int
+VERSION1: int
+W: int
+WORD: int
+X: int
+VERBOSE: int
+
+DEFAULT_VERSION: int

stubs/regex/regex/regex.pyi

@@ -0,0 +1,154 @@
+from typing import Any, AnyStr, Callable, overload
+
+from . import _regex
+from ._regex_core import *
+
+__version__: str
+
+def compile(
+    pattern: AnyStr | _regex.Pattern[AnyStr], flags: int = ..., ignore_unused: bool = ..., **kwargs: Any
+) -> _regex.Pattern[AnyStr]: ...
+def search(
+    pattern: AnyStr | _regex.Pattern[AnyStr],
+    string: AnyStr,
+    flags: int = ...,
+    pos: int | None = ...,
+    endpos: int | None = ...,
+    partial: bool = ...,
+    concurrent: bool | None = ...,
+    timeout: int | None = ...,
+    ignore_unused: bool = ...,
+    **kwargs: Any,
+) -> _regex.Match[AnyStr] | None: ...
+def match(
+    pattern: AnyStr | _regex.Pattern[AnyStr],
+    string: AnyStr,
+    flags: int = ...,
+    pos: int | None = ...,
+    endpos: int | None = ...,
+    partial: bool = ...,
+    concurrent: bool | None = ...,
+    timeout: int | None = ...,
+    ignore_unused: bool = ...,
+    **kwargs: Any,
+) -> _regex.Match[AnyStr] | None: ...
+def fullmatch(
+    pattern: AnyStr | _regex.Pattern[AnyStr],
+    string: AnyStr,
+    flags: int = ...,
+    pos: int | None = ...,
+    endpos: int | None = ...,
+    partial: bool = ...,
+    concurrent: bool | None = ...,
+    timeout: int | None = ...,
+    ignore_unused: bool = ...,
+    **kwargs: Any,
+) -> _regex.Match[AnyStr] | None: ...
+def split(
+    pattern: AnyStr | _regex.Pattern[AnyStr],
+    string: AnyStr,
+    maxsplit: int = ...,
+    flags: int = ...,
+    concurrent: bool | None = ...,
+    timeout: int | None = ...,
+    ignore_unused: bool = ...,
+    **kwargs: Any,
+) -> list[AnyStr | Any]: ...
+def splititer(
+    pattern: AnyStr | _regex.Pattern[AnyStr],
+    string: AnyStr,
+    maxsplit: int = ...,
+    flags: int = ...,
+    concurrent: bool | None = ...,
+    timeout: int | None = ...,
+    ignore_unused: bool = ...,
+    **kwargs: Any,
+) -> _regex.Splitter[AnyStr]: ...
+def findall(
+    pattern: AnyStr | _regex.Pattern[AnyStr],
+    string: AnyStr,
+    flags: int = ...,
+    pos: int | None = ...,
+    endpos: int | None = ...,
+    overlapped: bool = ...,
+    concurrent: bool | None = ...,
+    timeout: int | None = ...,
+    ignore_unused: bool = ...,
+    **kwargs: Any,
+) -> list[Any]: ...
+def finditer(
+    pattern: AnyStr | _regex.Pattern[AnyStr],
+    string: AnyStr,
+    flags: int = ...,
+    pos: int | None = ...,
+    endpos: int | None = ...,
+    overlapped: bool = ...,
+    partial: bool = ...,
+    concurrent: bool | None = ...,
+    timeout: int | None = ...,
+    ignore_unused: bool = ...,
+    **kwargs: Any,
+) -> _regex.Scanner[AnyStr]: ...
+def sub(
+    pattern: AnyStr | _regex.Pattern[AnyStr],
+    repl: AnyStr | Callable[[_regex.Match[AnyStr]], AnyStr],
+    string: AnyStr,
+    count: int = ...,
+    flags: int = ...,
+    pos: int | None = ...,
+    endpos: int | None = ...,
+    concurrent: bool | None = ...,
+    timeout: int | None = ...,
+    ignore_unused: bool = ...,
+    **kwargs: Any,
+) -> AnyStr: ...
+def subf(
+    pattern: AnyStr | _regex.Pattern[AnyStr],
+    format: AnyStr | Callable[[_regex.Match[AnyStr]], AnyStr],
+    string: AnyStr,
+    count: int = ...,
+    flags: int = ...,
+    pos: int | None = ...,
+    endpos: int | None = ...,
+    concurrent: bool | None = ...,
+    timeout: int | None = ...,
+    ignore_unused: bool = ...,
+    **kwargs: Any,
+) -> AnyStr: ...
+def subn(
+    pattern: AnyStr | _regex.Pattern[AnyStr],
+    repl: AnyStr | Callable[[_regex.Match[AnyStr]], AnyStr],
+    string: AnyStr,
+    count: int = ...,
+    flags: int = ...,
+    pos: int | None = ...,
+    endpos: int | None = ...,
+    concurrent: bool | None = ...,
+    timeout: int | None = ...,
+    ignore_unused: bool = ...,
+    **kwargs: Any,
+) -> tuple[AnyStr, int]: ...
+def subfn(
+    pattern: AnyStr | _regex.Pattern[AnyStr],
+    format: AnyStr | Callable[[_regex.Match[AnyStr]], AnyStr],
+    string: AnyStr,
+    count: int = ...,
+    flags: int = ...,
+    pos: int | None = ...,
+    endpos: int | None = ...,
+    concurrent: bool | None = ...,
+    timeout: int | None = ...,
+    ignore_unused: bool = ...,
+    **kwargs: Any,
+) -> tuple[AnyStr, int]: ...
+def purge() -> None: ...
+@overload
+def cache_all(value: bool = ...) -> None: ...
+@overload
+def cache_all(value: None) -> bool: ...
+def escape(pattern: AnyStr, special_only: bool = ..., literal_spaces: bool = ...) -> AnyStr: ...
+def template(pattern: AnyStr | _regex.Pattern[AnyStr], flags: int = ...) -> _regex.Pattern[AnyStr]: ...
+
+Pattern = _regex.Pattern
+Match = _regex.Match
+Regex = compile