basedpyright 1.13.2 → 1.13.3

package/dist/typeshed-fallback/stdlib/re.pyi

@@ -57,135 +57,297 @@ _T = TypeVar("_T")
 @final
 class Match(Generic[AnyStr]):
     @property
-    def pos(self) -> int: ...
+    def pos(self) -> int:
+        """The index into the string at which the RE engine started looking for a match."""
+        ...
     @property
-    def endpos(self) -> int: ...
+    def endpos(self) -> int:
+        """The index into the string beyond which the RE engine will not go."""
+        ...
     @property
-    def lastindex(self) -> int | None: ...
+    def lastindex(self) -> int | None:
+        """The integer index of the last matched capturing group."""
+        ...
     @property
-    def lastgroup(self) -> str | None: ...
+    def lastgroup(self) -> str | None:
+        """The name of the last matched capturing group."""
+        ...
     @property
-    def string(self) -> AnyStr: ...
+    def string(self) -> AnyStr:
+        """The string passed to match() or search()."""
+        ...
 
     # The regular expression object whose match() or search() method produced
     # this match instance.
     @property
-    def re(self) -> Pattern[AnyStr]: ...
+    def re(self) -> Pattern[AnyStr]:
+        """The regular expression object."""
+        ...
     @overload
-    def expand(self: Match[str], template: str) -> str: ...
+    def expand(self: Match[str], template: str) -> str:
+        """Return the string obtained by doing backslash substitution on the string template, as done by the sub() method."""
+        ...
     @overload
-    def expand(self: Match[bytes], template: ReadableBuffer) -> bytes: ...  # type: ignore[overload-overlap]
+    def expand(self: Match[bytes], template: ReadableBuffer) -> bytes:
+        """Return the string obtained by doing backslash substitution on the string template, as done by the sub() method."""
+        ...
     @overload
-    def expand(self, template: AnyStr) -> AnyStr: ...
+    def expand(self, template: AnyStr) -> AnyStr:
+        """Return the string obtained by doing backslash substitution on the string template, as done by the sub() method."""
+        ...
     # group() returns "AnyStr" or "AnyStr | None", depending on the pattern.
     @overload
-    def group(self, group: Literal[0] = 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, ...]: ...
+    def group(self, group: Literal[0] = 0, /) -> AnyStr:
+        """
+        group([group1, ...]) -> str or tuple.
+        Return subgroup(s) of the match by indices or names.
+        For 0 returns the entire match.
+        """
+        ...
+    @overload
+    def group(self, group: str | int, /) -> AnyStr | Any:
+        """
+        group([group1, ...]) -> str or tuple.
+        Return subgroup(s) of the match by indices or names.
+        For 0 returns the entire match.
+        """
+        ...
+    @overload
+    def group(self, group1: str | int, group2: str | int, /, *groups: str | int) -> tuple[AnyStr | Any, ...]:
+        """
+        group([group1, ...]) -> str or tuple.
+        Return subgroup(s) of the match by indices or names.
+        For 0 returns the entire match.
+        """
+        ...
     # 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, ...]: ...
+    def groups(self) -> tuple[AnyStr | Any, ...]:
+        """
+        Return a tuple containing all the subgroups of the match, from 1.
+
+        default
+          Is used for groups that did not participate in the match.
+        """
+        ...
+    @overload
+    def groups(self, default: _T) -> tuple[AnyStr | _T, ...]:
+        """
+        Return a tuple containing all the subgroups of the match, from 1.
+
+        default
+          Is used for groups that did not participate in the match.
+        """
+        ...
     # 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 = 0, /) -> int: ...
-    def end(self, group: int | str = 0, /) -> int: ...
-    def span(self, group: int | str = 0, /) -> tuple[int, int]: ...
+    def groupdict(self) -> dict[str, AnyStr | Any]:
+        """
+        Return a dictionary containing all the named subgroups of the match, keyed by the subgroup name.
+
+        default
+          Is used for groups that did not participate in the match.
+        """
+        ...
+    @overload
+    def groupdict(self, default: _T) -> dict[str, AnyStr | _T]:
+        """
+        Return a dictionary containing all the named subgroups of the match, keyed by the subgroup name.
+
+        default
+          Is used for groups that did not participate in the match.
+        """
+        ...
+    def start(self, group: int | str = 0, /) -> int:
+        """Return index of the start of the substring matched by group."""
+        ...
+    def end(self, group: int | str = 0, /) -> int:
+        """Return index of the end of the substring matched by group."""
+        ...
+    def span(self, group: int | str = 0, /) -> tuple[int, int]:
+        """For match object m, return the 2-tuple (m.start(group), m.end(group))."""
+        ...
     @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: ...
+    def __getitem__(self, key: Literal[0], /) -> AnyStr:
+        """Return self[key]."""
+        ...
     @overload
-    def __getitem__(self, key: int | str, /) -> AnyStr | Any: ...
+    def __getitem__(self, key: int | str, /) -> AnyStr | Any:
+        """Return self[key]."""
+        ...
     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:
+            """See PEP 585"""
+            ...
 
 @final
 class Pattern(Generic[AnyStr]):
     @property
-    def flags(self) -> int: ...
+    def flags(self) -> int:
+        """The regex matching flags."""
+        ...
     @property
-    def groupindex(self) -> Mapping[str, int]: ...
+    def groupindex(self) -> Mapping[str, int]:
+        """A dictionary mapping group names to group numbers."""
+        ...
     @property
-    def groups(self) -> int: ...
+    def groups(self) -> int:
+        """The number of capturing groups in the pattern."""
+        ...
     @property
-    def pattern(self) -> AnyStr: ...
+    def pattern(self) -> AnyStr:
+        """The pattern string from which the RE object was compiled."""
+        ...
     @overload
-    def search(self: Pattern[str], string: str, pos: int = 0, endpos: int = sys.maxsize) -> Match[str] | None: ...
+    def search(self: Pattern[str], string: str, pos: int = 0, endpos: int = sys.maxsize) -> Match[str] | None:
+        """
+        Scan through string looking for a match, and return a corresponding match object instance.
+
+        Return None if no position in the string matches.
+        """
+        ...
     @overload
-    def search(self: Pattern[bytes], string: ReadableBuffer, pos: int = 0, endpos: int = sys.maxsize) -> Match[bytes] | None: ...  # type: ignore[overload-overlap]
+    def search(self: Pattern[bytes], string: ReadableBuffer, pos: int = 0, endpos: int = sys.maxsize) -> Match[bytes] | None:
+        """
+        Scan through string looking for a match, and return a corresponding match object instance.
+
+        Return None if no position in the string matches.
+        """
+        ...
     @overload
-    def search(self, string: AnyStr, pos: int = 0, endpos: int = sys.maxsize) -> Match[AnyStr] | None: ...
+    def search(self, string: AnyStr, pos: int = 0, endpos: int = sys.maxsize) -> Match[AnyStr] | None:
+        """
+        Scan through string looking for a match, and return a corresponding match object instance.
+
+        Return None if no position in the string matches.
+        """
+        ...
     @overload
-    def match(self: Pattern[str], string: str, pos: int = 0, endpos: int = sys.maxsize) -> Match[str] | None: ...
+    def match(self: Pattern[str], string: str, pos: int = 0, endpos: int = sys.maxsize) -> Match[str] | None:
+        """Matches zero or more characters at the beginning of the string."""
+        ...
     @overload
-    def match(self: Pattern[bytes], string: ReadableBuffer, pos: int = 0, endpos: int = sys.maxsize) -> Match[bytes] | None: ...  # type: ignore[overload-overlap]
+    def match(self: Pattern[bytes], string: ReadableBuffer, pos: int = 0, endpos: int = sys.maxsize) -> Match[bytes] | None:
+        """Matches zero or more characters at the beginning of the string."""
+        ...
     @overload
-    def match(self, string: AnyStr, pos: int = 0, endpos: int = sys.maxsize) -> Match[AnyStr] | None: ...
+    def match(self, string: AnyStr, pos: int = 0, endpos: int = sys.maxsize) -> Match[AnyStr] | None:
+        """Matches zero or more characters at the beginning of the string."""
+        ...
     @overload
-    def fullmatch(self: Pattern[str], string: str, pos: int = 0, endpos: int = sys.maxsize) -> Match[str] | None: ...
+    def fullmatch(self: Pattern[str], string: str, pos: int = 0, endpos: int = sys.maxsize) -> Match[str] | None:
+        """Matches against all of the string."""
+        ...
     @overload
-    def fullmatch(self: Pattern[bytes], string: ReadableBuffer, pos: int = 0, endpos: int = sys.maxsize) -> Match[bytes] | None: ...  # type: ignore[overload-overlap]
+    def fullmatch(self: Pattern[bytes], string: ReadableBuffer, pos: int = 0, endpos: int = sys.maxsize) -> Match[bytes] | None:
+        """Matches against all of the string."""
+        ...
     @overload
-    def fullmatch(self, string: AnyStr, pos: int = 0, endpos: int = sys.maxsize) -> Match[AnyStr] | None: ...
+    def fullmatch(self, string: AnyStr, pos: int = 0, endpos: int = sys.maxsize) -> Match[AnyStr] | None:
+        """Matches against all of the string."""
+        ...
     @overload
-    def split(self: Pattern[str], string: str, maxsplit: int = 0) -> list[str | Any]: ...
+    def split(self: Pattern[str], string: str, maxsplit: int = 0) -> list[str | Any]:
+        """Split string by the occurrences of pattern."""
+        ...
     @overload
-    def split(self: Pattern[bytes], string: ReadableBuffer, maxsplit: int = 0) -> list[bytes | Any]: ...
+    def split(self: Pattern[bytes], string: ReadableBuffer, maxsplit: int = 0) -> list[bytes | Any]:
+        """Split string by the occurrences of pattern."""
+        ...
     @overload
-    def split(self, string: AnyStr, maxsplit: int = 0) -> list[AnyStr | Any]: ...
+    def split(self, string: AnyStr, maxsplit: int = 0) -> list[AnyStr | Any]:
+        """Split string by the occurrences of pattern."""
+        ...
     # return type depends on the number of groups in the pattern
     @overload
-    def findall(self: Pattern[str], string: str, pos: int = 0, endpos: int = sys.maxsize) -> list[Any]: ...
+    def findall(self: Pattern[str], string: str, pos: int = 0, endpos: int = sys.maxsize) -> list[Any]:
+        """Return a list of all non-overlapping matches of pattern in string."""
+        ...
     @overload
-    def findall(self: Pattern[bytes], string: ReadableBuffer, pos: int = 0, endpos: int = sys.maxsize) -> list[Any]: ...
+    def findall(self: Pattern[bytes], string: ReadableBuffer, pos: int = 0, endpos: int = sys.maxsize) -> list[Any]:
+        """Return a list of all non-overlapping matches of pattern in string."""
+        ...
     @overload
-    def findall(self, string: AnyStr, pos: int = 0, endpos: int = sys.maxsize) -> list[AnyStr]: ...
+    def findall(self, string: AnyStr, pos: int = 0, endpos: int = sys.maxsize) -> list[AnyStr]:
+        """Return a list of all non-overlapping matches of pattern in string."""
+        ...
     @overload
-    def finditer(self: Pattern[str], string: str, pos: int = 0, endpos: int = sys.maxsize) -> Iterator[Match[str]]: ...
+    def finditer(self: Pattern[str], string: str, pos: int = 0, endpos: int = sys.maxsize) -> Iterator[Match[str]]:
+        """
+        Return an iterator over all non-overlapping matches for the RE pattern in string.
+
+        For each match, the iterator returns a match object.
+        """
+        ...
     @overload
-    def finditer(self: Pattern[bytes], string: ReadableBuffer, pos: int = 0, endpos: int = sys.maxsize) -> Iterator[Match[bytes]]: ...  # type: ignore[overload-overlap]
+    def finditer(self: Pattern[bytes], string: ReadableBuffer, pos: int = 0, endpos: int = sys.maxsize) -> Iterator[Match[bytes]]:
+        """
+        Return an iterator over all non-overlapping matches for the RE pattern in string.
+
+        For each match, the iterator returns a match object.
+        """
+        ...
     @overload
-    def finditer(self, string: AnyStr, pos: int = 0, endpos: int = sys.maxsize) -> Iterator[Match[AnyStr]]: ...
+    def finditer(self, string: AnyStr, pos: int = 0, endpos: int = sys.maxsize) -> Iterator[Match[AnyStr]]:
+        """
+        Return an iterator over all non-overlapping matches for the RE pattern in string.
+
+        For each match, the iterator returns a match object.
+        """
+        ...
     @overload
-    def sub(self: Pattern[str], repl: str | Callable[[Match[str]], str], string: str, count: int = 0) -> str: ...
+    def sub(self: Pattern[str], repl: str | Callable[[Match[str]], str], string: str, count: int = 0) -> str:
+        """Return the string obtained by replacing the leftmost non-overlapping occurrences of pattern in string by the replacement repl."""
+        ...
     @overload
     def sub(  # type: ignore[overload-overlap]
         self: Pattern[bytes],
         repl: ReadableBuffer | Callable[[Match[bytes]], ReadableBuffer],
         string: ReadableBuffer,
         count: int = 0,
-    ) -> bytes: ...
+    ) -> bytes:
+        """Return the string obtained by replacing the leftmost non-overlapping occurrences of pattern in string by the replacement repl."""
+        ...
     @overload
-    def sub(self, repl: AnyStr | Callable[[Match[AnyStr]], AnyStr], string: AnyStr, count: int = 0) -> AnyStr: ...
+    def sub(self, repl: AnyStr | Callable[[Match[AnyStr]], AnyStr], string: AnyStr, count: int = 0) -> AnyStr:
+        """Return the string obtained by replacing the leftmost non-overlapping occurrences of pattern in string by the replacement repl."""
+        ...
     @overload
-    def subn(self: Pattern[str], repl: str | Callable[[Match[str]], str], string: str, count: int = 0) -> tuple[str, int]: ...
+    def subn(self: Pattern[str], repl: str | Callable[[Match[str]], str], string: str, count: int = 0) -> tuple[str, int]:
+        """Return the tuple (new_string, number_of_subs_made) found by replacing the leftmost non-overlapping occurrences of pattern with the replacement repl."""
+        ...
     @overload
     def subn(  # type: ignore[overload-overlap]
         self: Pattern[bytes],
         repl: ReadableBuffer | Callable[[Match[bytes]], ReadableBuffer],
         string: ReadableBuffer,
         count: int = 0,
-    ) -> tuple[bytes, int]: ...
+    ) -> tuple[bytes, int]:
+        """Return the tuple (new_string, number_of_subs_made) found by replacing the leftmost non-overlapping occurrences of pattern with the replacement repl."""
+        ...
     @overload
-    def subn(self, repl: AnyStr | Callable[[Match[AnyStr]], AnyStr], string: AnyStr, count: int = 0) -> tuple[AnyStr, int]: ...
+    def subn(self, repl: AnyStr | Callable[[Match[AnyStr]], AnyStr], string: AnyStr, count: int = 0) -> tuple[AnyStr, int]:
+        """Return the tuple (new_string, number_of_subs_made) found by replacing the leftmost non-overlapping occurrences of pattern with the replacement repl."""
+        ...
     def __copy__(self) -> Pattern[AnyStr]: ...
     def __deepcopy__(self, memo: Any, /) -> Pattern[AnyStr]: ...
-    def __eq__(self, value: object, /) -> bool: ...
-    def __hash__(self) -> int: ...
+    def __eq__(self, value: object, /) -> bool:
+        """Return self==value."""
+        ...
+    def __hash__(self) -> int:
+        """Return hash(self)."""
+        ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias:
+            """See PEP 585"""
+            ...
 
 # ----- re variables and constants -----
 

package/dist/typeshed-fallback/stdlib/sched.pyi

@@ -39,4 +39,11 @@ class scheduler:
     def cancel(self, event: Event) -> None: ...
     def empty(self) -> bool: ...
     @property
-    def queue(self) -> list[Event]: ...
+    def queue(self) -> list[Event]:
+        """
+        An ordered list of upcoming events.
+
+        Events are named tuples with fields for:
+            time, priority, action, arguments, kwargs
+        """
+        ...

package/dist/typeshed-fallback/stdlib/signal.pyi

@@ -67,7 +67,14 @@ SIG_IGN: Handlers
 _SIGNUM: TypeAlias = int | Signals
 _HANDLER: TypeAlias = Callable[[int, FrameType | None], Any] | int | Handlers | None
 
-def default_int_handler(signalnum: int, frame: FrameType | None, /) -> Never: ...
+def default_int_handler(signalnum: int, frame: FrameType | None, /) -> Never:
+    """
+    default_int_handler(...)
+
+    The default handler for SIGINT installed by Python.
+    It raises KeyboardInterrupt.
+    """
+    ...
 
 if sys.version_info >= (3, 10):  # arguments changed in 3.10.2
     def getsignal(signalnum: _SIGNUM) -> _HANDLER: ...
@@ -130,17 +137,41 @@ else:
     SIG_BLOCK = Sigmasks.SIG_BLOCK
     SIG_UNBLOCK = Sigmasks.SIG_UNBLOCK
     SIG_SETMASK = Sigmasks.SIG_SETMASK
-    def alarm(seconds: int, /) -> int: ...
-    def getitimer(which: int, /) -> tuple[float, float]: ...
-    def pause() -> None: ...
-    def pthread_kill(thread_id: int, signalnum: int, /) -> None: ...
+    def alarm(seconds: int, /) -> int:
+        """Arrange for SIGALRM to arrive after the given number of seconds."""
+        ...
+    def getitimer(which: int, /) -> tuple[float, float]:
+        """Returns current value of given itimer."""
+        ...
+    def pause() -> None:
+        """Wait until a signal arrives."""
+        ...
+    def pthread_kill(thread_id: int, signalnum: int, /) -> None:
+        """Send a signal to a thread."""
+        ...
     if sys.version_info >= (3, 10):  # arguments changed in 3.10.2
         def pthread_sigmask(how: int, mask: Iterable[int]) -> set[_SIGNUM]: ...
     else:
         def pthread_sigmask(how: int, mask: Iterable[int], /) -> set[_SIGNUM]: ...
 
-    def setitimer(which: int, seconds: float, interval: float = 0.0, /) -> tuple[float, float]: ...
-    def siginterrupt(signalnum: int, flag: bool, /) -> None: ...
+    def setitimer(which: int, seconds: float, interval: float = 0.0, /) -> tuple[float, float]:
+        """
+        Sets given itimer (one of ITIMER_REAL, ITIMER_VIRTUAL or ITIMER_PROF).
+
+        The timer will fire after value seconds and after that every interval seconds.
+        The itimer can be cleared by setting seconds to zero.
+
+        Returns old values as a tuple: (delay, interval).
+        """
+        ...
+    def siginterrupt(signalnum: int, flag: bool, /) -> None:
+        """
+        Change system call restart behaviour.
+
+        If flag is False, system calls will be restarted when interrupted by
+        signal sig, else system calls will be interrupted.
+        """
+        ...
     def sigpending() -> Any: ...
     if sys.version_info >= (3, 10):  # argument changed in 3.10.2
         def sigwait(sigset: Iterable[int]) -> _SIGNUM: ...
@@ -161,27 +192,72 @@ else:
                 __match_args__: Final = ("si_signo", "si_code", "si_errno", "si_pid", "si_uid", "si_status", "si_band")
 
             @property
-            def si_signo(self) -> int: ...
+            def si_signo(self) -> int:
+                """signal number"""
+                ...
             @property
-            def si_code(self) -> int: ...
+            def si_code(self) -> int:
+                """signal code"""
+                ...
             @property
-            def si_errno(self) -> int: ...
+            def si_errno(self) -> int:
+                """errno associated with this signal"""
+                ...
             @property
-            def si_pid(self) -> int: ...
+            def si_pid(self) -> int:
+                """sending process ID"""
+                ...
             @property
-            def si_uid(self) -> int: ...
+            def si_uid(self) -> int:
+                """real user ID of sending process"""
+                ...
             @property
-            def si_status(self) -> int: ...
+            def si_status(self) -> int:
+                """exit value or signal"""
+                ...
             @property
-            def si_band(self) -> int: ...
+            def si_band(self) -> int:
+                """band event for SIGPOLL"""
+                ...
+
+        def sigtimedwait(sigset: Iterable[int], timeout: float, /) -> struct_siginfo | None:
+            """
+            Like sigwaitinfo(), but with a timeout.
 
-        def sigtimedwait(sigset: Iterable[int], timeout: float, /) -> struct_siginfo | None: ...
-        def sigwaitinfo(sigset: Iterable[int], /) -> struct_siginfo: ...
+            The timeout is specified in seconds, with floating point numbers allowed.
+            """
+            ...
+        def sigwaitinfo(sigset: Iterable[int], /) -> struct_siginfo:
+            """
+            Wait synchronously until one of the signals in *sigset* is delivered.
 
-def strsignal(signalnum: _SIGNUM, /) -> str | None: ...
+            Returns a struct_siginfo containing information about the signal.
+            """
+            ...
+
+def strsignal(signalnum: _SIGNUM, /) -> str | None:
+    """
+    Return the system description of the given signal.
+
+    The return values can be such as "Interrupt", "Segmentation fault", etc.
+    Returns None if the signal is not recognized.
+    """
+    ...
 def valid_signals() -> set[Signals]: ...
-def raise_signal(signalnum: _SIGNUM, /) -> None: ...
-def set_wakeup_fd(fd: int, /, *, warn_on_full_buffer: bool = ...) -> int: ...
+def raise_signal(signalnum: _SIGNUM, /) -> None:
+    """Send a signal to the executing process."""
+    ...
+def set_wakeup_fd(fd: int, /, *, warn_on_full_buffer: bool = ...) -> int:
+    """
+    set_wakeup_fd(fd, *, warn_on_full_buffer=True) -> fd
+
+    Sets the fd to be written to (with the signal number) when a signal
+    comes in.  A library can use this to wakeup select or poll.
+    The previous fd or -1 is returned.
+
+    The fd must be non-blocking.
+    """
+    ...
 
 if sys.version_info >= (3, 9):
     if sys.platform == "linux":