diff --git a/stubs/regex/@tests/stubtest_allowlist.txt b/stubs/regex/@tests/stubtest_allowlist.txt new file mode 100644 index 000000000000..2f05cbed12c7 --- /dev/null +++ b/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 diff --git a/stubs/regex/METADATA.toml b/stubs/regex/METADATA.toml new file mode 100644 index 000000000000..1ebc1e5e1410 --- /dev/null +++ b/stubs/regex/METADATA.toml @@ -0,0 +1 @@ +version = "2021.11.10" diff --git a/stubs/regex/regex/__init__.pyi b/stubs/regex/regex/__init__.pyi new file mode 100644 index 000000000000..f310be632191 --- /dev/null +++ b/stubs/regex/regex/__init__.pyi @@ -0,0 +1 @@ +from .regex import * diff --git a/stubs/regex/regex/_regex.pyi b/stubs/regex/regex/_regex.pyi new file mode 100644 index 000000000000..0e591540092d --- /dev/null +++ b/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: ... diff --git a/stubs/regex/regex/_regex_core.pyi b/stubs/regex/regex/_regex_core.pyi new file mode 100644 index 000000000000..c3f5685c13dd --- /dev/null +++ b/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 diff --git a/stubs/regex/regex/regex.pyi b/stubs/regex/regex/regex.pyi new file mode 100644 index 000000000000..69812a26c45e --- /dev/null +++ b/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: float | 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: float | 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: float | 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: float | 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: float | 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: float | 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: float | 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: float | 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: float | 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: float | 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: float | 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