Add regex stubs

stubs/regex/@tests/stubtest_allowlist.txt

@@ -0,0 +1,6 @@
+# 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.
+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,192 @@
+from _typeshed import Self
+from typing import Any, AnyStr, Callable, Generic, Mapping, TypeVar, overload
+from typing_extensions import Literal, final
+
+_T = TypeVar("_T")
+
+@final
+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: float | None = ...,
+ ) -> Match[AnyStr] | None: ...
+ def match(
+ self,
+ string: AnyStr,
+ pos: int | None = ...,
+ endpos: int | None = ...,
+ concurrent: bool | None = ...,
+ timeout: float | None = ...,
+ ) -> Match[AnyStr] | None: ...
+ def fullmatch(
+ self,
+ string: AnyStr,
+ pos: int | None = ...,
+ endpos: int | None = ...,
+ concurrent: bool | None = ...,
+ timeout: float | None = ...,
+ ) -> Match[AnyStr] | None: ...
+ def split(
+ self, string: AnyStr, maxsplit: int = ..., concurrent: bool | None = ..., timeout: float | None = ...
+ ) -> list[AnyStr | Any]: ...
+ def splititer(
+ self, string: AnyStr, maxsplit: int = ..., concurrent: bool | None = ..., timeout: float | None = ...
+ ) -> Splitter[AnyStr]: ...
+ def findall(
+ self,
+ string: AnyStr,
+ pos: int | None = ...,
+ endpos: int | None = ...,
+ overlapped: bool = ...,
+ concurrent: bool | None = ...,
+ timeout: float | None = ...,
+ ) -> list[Any]: ...
+ def finditer(
+ self,
+ string: AnyStr,
+ pos: int | None = ...,
+ endpos: int | None = ...,
+ overlapped: bool = ...,
+ concurrent: bool | None = ...,
+ timeout: float | 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: float | 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: float | 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: float | 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: float | None = ...,
+ ) -> tuple[AnyStr, int]: ...
+ def scanner(
+ self,
+ string: AnyStr,
+ pos: int | None = ...,
+ endpos: int | None = ...,
+ overlapped: bool = ...,
+ concurrent: bool | None = ...,
+ timeout: float | None = ...,
+ ) -> Scanner[AnyStr]: ...
+
+@final
+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: Literal[0] = ...) -> AnyStr: ...
+ @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: ...
+
+@final
+class Splitter(Generic[AnyStr]):
+
+ pattern: Pattern[AnyStr]
+ def __iter__(self: Self) -> Self: ...
+ def __next__(self) -> AnyStr | Any: ...
+ def split(self) -> AnyStr | Any: ...
+
+@final
+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