basedpyright 1.12.6 → 1.13.0

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

@@ -1,3 +1,8 @@
+"""
+This module provides access to mathematical functions for complex
+numbers.
+"""
+
 from typing import SupportsComplex, SupportsFloat, SupportsIndex
 from typing_extensions import TypeAlias
 
@@ -11,26 +16,97 @@ tau: float
 
 _C: TypeAlias = SupportsFloat | SupportsComplex | SupportsIndex | complex
 
-def acos(z: _C, /) -> complex: ...
-def acosh(z: _C, /) -> complex: ...
-def asin(z: _C, /) -> complex: ...
-def asinh(z: _C, /) -> complex: ...
-def atan(z: _C, /) -> complex: ...
-def atanh(z: _C, /) -> complex: ...
-def cos(z: _C, /) -> complex: ...
-def cosh(z: _C, /) -> complex: ...
-def exp(z: _C, /) -> complex: ...
-def isclose(a: _C, b: _C, *, rel_tol: SupportsFloat = 1e-09, abs_tol: SupportsFloat = 0.0) -> bool: ...
-def isinf(z: _C, /) -> bool: ...
-def isnan(z: _C, /) -> bool: ...
-def log(x: _C, base: _C = ..., /) -> complex: ...
-def log10(z: _C, /) -> complex: ...
-def phase(z: _C, /) -> float: ...
-def polar(z: _C, /) -> tuple[float, float]: ...
-def rect(r: float, phi: float, /) -> complex: ...
-def sin(z: _C, /) -> complex: ...
-def sinh(z: _C, /) -> complex: ...
-def sqrt(z: _C, /) -> complex: ...
-def tan(z: _C, /) -> complex: ...
-def tanh(z: _C, /) -> complex: ...
-def isfinite(z: _C, /) -> bool: ...
+def acos(z: _C, /) -> complex:
+    """Return the arc cosine of z."""
+    ...
+def acosh(z: _C, /) -> complex:
+    """Return the inverse hyperbolic cosine of z."""
+    ...
+def asin(z: _C, /) -> complex:
+    """Return the arc sine of z."""
+    ...
+def asinh(z: _C, /) -> complex:
+    """Return the inverse hyperbolic sine of z."""
+    ...
+def atan(z: _C, /) -> complex:
+    """Return the arc tangent of z."""
+    ...
+def atanh(z: _C, /) -> complex:
+    """Return the inverse hyperbolic tangent of z."""
+    ...
+def cos(z: _C, /) -> complex:
+    """Return the cosine of z."""
+    ...
+def cosh(z: _C, /) -> complex:
+    """Return the hyperbolic cosine of z."""
+    ...
+def exp(z: _C, /) -> complex:
+    """Return the exponential value e**z."""
+    ...
+def isclose(a: _C, b: _C, *, rel_tol: SupportsFloat = 1e-09, abs_tol: SupportsFloat = 0.0) -> bool:
+    """
+    Determine whether two complex numbers are close in value.
+
+      rel_tol
+        maximum difference for being considered "close", relative to the
+        magnitude of the input values
+      abs_tol
+        maximum difference for being considered "close", regardless of the
+        magnitude of the input values
+
+    Return True if a is close in value to b, and False otherwise.
+
+    For the values to be considered close, the difference between them must be
+    smaller than at least one of the tolerances.
+
+    -inf, inf and NaN behave similarly to the IEEE 754 Standard. That is, NaN is
+    not close to anything, even itself. inf and -inf are only close to themselves.
+    """
+    ...
+def isinf(z: _C, /) -> bool:
+    """Checks if the real or imaginary part of z is infinite."""
+    ...
+def isnan(z: _C, /) -> bool:
+    """Checks if the real or imaginary part of z not a number (NaN)."""
+    ...
+def log(x: _C, base: _C = ..., /) -> complex:
+    """
+    log(z[, base]) -> the logarithm of z to the given base.
+
+    If the base not specified, returns the natural logarithm (base e) of z.
+    """
+    ...
+def log10(z: _C, /) -> complex:
+    """Return the base-10 logarithm of z."""
+    ...
+def phase(z: _C, /) -> float:
+    """Return argument, also known as the phase angle, of a complex."""
+    ...
+def polar(z: _C, /) -> tuple[float, float]:
+    """
+    Convert a complex from rectangular coordinates to polar coordinates.
+
+    r is the distance from 0 and phi the phase angle.
+    """
+    ...
+def rect(r: float, phi: float, /) -> complex:
+    """Convert from polar coordinates to rectangular coordinates."""
+    ...
+def sin(z: _C, /) -> complex:
+    """Return the sine of z."""
+    ...
+def sinh(z: _C, /) -> complex:
+    """Return the hyperbolic sine of z."""
+    ...
+def sqrt(z: _C, /) -> complex:
+    """Return the square root of z."""
+    ...
+def tan(z: _C, /) -> complex:
+    """Return the tangent of z."""
+    ...
+def tanh(z: _C, /) -> complex:
+    """Return the hyperbolic tangent of z."""
+    ...
+def isfinite(z: _C, /) -> bool:
+    """Return True if both the real and imaginary parts of z are finite, else False."""
+    ...

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

@@ -1,3 +1,18 @@
+"""
+This module makes available standard errno system symbols.
+
+The value of each symbol is the corresponding integer value,
+e.g., on most systems, errno.ENOENT equals the integer 2.
+
+The dictionary errno.errorcode maps numeric codes to symbol names,
+e.g., errno.errorcode[2] could be the string 'ENOENT'.
+
+Symbols that are not relevant to the underlying system are not defined.
+
+To map error codes to error messages, use the function os.strerror(),
+e.g. os.strerror(2) could return 'No such file or directory'.
+"""
+
 import sys
 from collections.abc import Mapping
 

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

@@ -1,13 +1,38 @@
+"""faulthandler module."""
+
 import sys
 from _typeshed import FileDescriptorLike
 
-def cancel_dump_traceback_later() -> None: ...
-def disable() -> None: ...
-def dump_traceback(file: FileDescriptorLike = ..., all_threads: bool = ...) -> None: ...
-def dump_traceback_later(timeout: float, repeat: bool = ..., file: FileDescriptorLike = ..., exit: bool = ...) -> None: ...
-def enable(file: FileDescriptorLike = ..., all_threads: bool = ...) -> None: ...
-def is_enabled() -> bool: ...
+def cancel_dump_traceback_later() -> None:
+    """
+    cancel_dump_traceback_later():
+    cancel the previous call to dump_traceback_later().
+    """
+    ...
+def disable() -> None:
+    """disable(): disable the fault handler"""
+    ...
+def dump_traceback(file: FileDescriptorLike = ..., all_threads: bool = ...) -> None:
+    """dump_traceback(file=sys.stderr, all_threads=True): dump the traceback of the current thread, or of all threads if all_threads is True, into file"""
+    ...
+def dump_traceback_later(timeout: float, repeat: bool = ..., file: FileDescriptorLike = ..., exit: bool = ...) -> None:
+    """
+    dump_traceback_later(timeout, repeat=False, file=sys.stderrn, exit=False):
+    dump the traceback of all threads in timeout seconds,
+    or each timeout seconds if repeat is True. If exit is True, call _exit(1) which is not safe.
+    """
+    ...
+def enable(file: FileDescriptorLike = ..., all_threads: bool = ...) -> None:
+    """enable(file=sys.stderr, all_threads=True): enable the fault handler"""
+    ...
+def is_enabled() -> bool:
+    """is_enabled()->bool: check if the handler is enabled"""
+    ...
 
 if sys.platform != "win32":
-    def register(signum: int, file: FileDescriptorLike = ..., all_threads: bool = ..., chain: bool = ...) -> None: ...
-    def unregister(signum: int, /) -> None: ...
+    def register(signum: int, file: FileDescriptorLike = ..., all_threads: bool = ..., chain: bool = ...) -> None:
+        """register(signum, file=sys.stderr, all_threads=True, chain=False): register a handler for the signal 'signum': dump the traceback of the current thread, or of all threads if all_threads is True, into file"""
+        ...
+    def unregister(signum: int, /) -> None:
+        """unregister(signum): unregister the handler of the signal 'signum' registered by register()"""
+        ...

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

@@ -1,3 +1,10 @@
+"""
+This module performs file control and I/O control on file
+descriptors.  It is an interface to the fcntl() and ioctl() Unix
+routines.  File descriptors can be obtained with the fileno() method of
+a file or socket object.
+"""
+
 import sys
 from _typeshed import FileDescriptorLike, ReadOnlyBuffer, WriteableBuffer
 from typing import Any, Literal, overload
@@ -106,22 +113,206 @@ if sys.platform != "win32":
         FICLONERANGE: int
 
     @overload
-    def fcntl(fd: FileDescriptorLike, cmd: int, arg: int = 0, /) -> int: ...
+    def fcntl(fd: FileDescriptorLike, cmd: int, arg: int = 0, /) -> int:
+        """
+        Perform the operation `cmd` on file descriptor fd.
+
+        The values used for `cmd` are operating system dependent, and are available
+        as constants in the fcntl module, using the same names as used in
+        the relevant C header files.  The argument arg is optional, and
+        defaults to 0; it may be an int or a string.  If arg is given as a string,
+        the return value of fcntl is a string of that length, containing the
+        resulting value put in the arg buffer by the operating system.  The length
+        of the arg string is not allowed to exceed 1024 bytes.  If the arg given
+        is an integer or if none is specified, the result value is an integer
+        corresponding to the return value of the fcntl call in the C code.
+        """
+        ...
     @overload
-    def fcntl(fd: FileDescriptorLike, cmd: int, arg: str | ReadOnlyBuffer, /) -> bytes: ...
+    def fcntl(fd: FileDescriptorLike, cmd: int, arg: str | ReadOnlyBuffer, /) -> bytes:
+        """
+        Perform the operation `cmd` on file descriptor fd.
+
+        The values used for `cmd` are operating system dependent, and are available
+        as constants in the fcntl module, using the same names as used in
+        the relevant C header files.  The argument arg is optional, and
+        defaults to 0; it may be an int or a string.  If arg is given as a string,
+        the return value of fcntl is a string of that length, containing the
+        resulting value put in the arg buffer by the operating system.  The length
+        of the arg string is not allowed to exceed 1024 bytes.  If the arg given
+        is an integer or if none is specified, the result value is an integer
+        corresponding to the return value of the fcntl call in the C code.
+        """
+        ...
     # If arg is an int, return int
     @overload
-    def ioctl(fd: FileDescriptorLike, request: int, arg: int = 0, mutate_flag: bool = True, /) -> int: ...
+    def ioctl(fd: FileDescriptorLike, request: int, arg: int = 0, mutate_flag: bool = True, /) -> int:
+        """
+        Perform the operation `request` on file descriptor `fd`.
+
+        The values used for `request` are operating system dependent, and are available
+        as constants in the fcntl or termios library modules, using the same names as
+        used in the relevant C header files.
+
+        The argument `arg` is optional, and defaults to 0; it may be an int or a
+        buffer containing character data (most likely a string or an array).
+
+        If the argument is a mutable buffer (such as an array) and if the
+        mutate_flag argument (which is only allowed in this case) is true then the
+        buffer is (in effect) passed to the operating system and changes made by
+        the OS will be reflected in the contents of the buffer after the call has
+        returned.  The return value is the integer returned by the ioctl system
+        call.
+
+        If the argument is a mutable buffer and the mutable_flag argument is false,
+        the behavior is as if a string had been passed.
+
+        If the argument is an immutable buffer (most likely a string) then a copy
+        of the buffer is passed to the operating system and the return value is a
+        string of the same length containing whatever the operating system put in
+        the buffer.  The length of the arg buffer in this case is not allowed to
+        exceed 1024 bytes.
+
+        If the arg given is an integer or if none is specified, the result value is
+        an integer corresponding to the return value of the ioctl call in the C
+        code.
+        """
+        ...
     # The return type works as follows:
     # - If arg is a read-write buffer, return int if mutate_flag is True, otherwise bytes
     # - If arg is a read-only buffer, return bytes (and ignore the value of mutate_flag)
     # We can't represent that precisely as we can't distinguish between read-write and read-only
     # buffers, so we add overloads for a few unambiguous cases and use Any for the rest.
     @overload
-    def ioctl(fd: FileDescriptorLike, request: int, arg: bytes, mutate_flag: bool = True, /) -> bytes: ...
+    def ioctl(fd: FileDescriptorLike, request: int, arg: bytes, mutate_flag: bool = True, /) -> bytes:
+        """
+        Perform the operation `request` on file descriptor `fd`.
+
+        The values used for `request` are operating system dependent, and are available
+        as constants in the fcntl or termios library modules, using the same names as
+        used in the relevant C header files.
+
+        The argument `arg` is optional, and defaults to 0; it may be an int or a
+        buffer containing character data (most likely a string or an array).
+
+        If the argument is a mutable buffer (such as an array) and if the
+        mutate_flag argument (which is only allowed in this case) is true then the
+        buffer is (in effect) passed to the operating system and changes made by
+        the OS will be reflected in the contents of the buffer after the call has
+        returned.  The return value is the integer returned by the ioctl system
+        call.
+
+        If the argument is a mutable buffer and the mutable_flag argument is false,
+        the behavior is as if a string had been passed.
+
+        If the argument is an immutable buffer (most likely a string) then a copy
+        of the buffer is passed to the operating system and the return value is a
+        string of the same length containing whatever the operating system put in
+        the buffer.  The length of the arg buffer in this case is not allowed to
+        exceed 1024 bytes.
+
+        If the arg given is an integer or if none is specified, the result value is
+        an integer corresponding to the return value of the ioctl call in the C
+        code.
+        """
+        ...
     @overload
-    def ioctl(fd: FileDescriptorLike, request: int, arg: WriteableBuffer, mutate_flag: Literal[False], /) -> bytes: ...
+    def ioctl(fd: FileDescriptorLike, request: int, arg: WriteableBuffer, mutate_flag: Literal[False], /) -> bytes:
+        """
+        Perform the operation `request` on file descriptor `fd`.
+
+        The values used for `request` are operating system dependent, and are available
+        as constants in the fcntl or termios library modules, using the same names as
+        used in the relevant C header files.
+
+        The argument `arg` is optional, and defaults to 0; it may be an int or a
+        buffer containing character data (most likely a string or an array).
+
+        If the argument is a mutable buffer (such as an array) and if the
+        mutate_flag argument (which is only allowed in this case) is true then the
+        buffer is (in effect) passed to the operating system and changes made by
+        the OS will be reflected in the contents of the buffer after the call has
+        returned.  The return value is the integer returned by the ioctl system
+        call.
+
+        If the argument is a mutable buffer and the mutable_flag argument is false,
+        the behavior is as if a string had been passed.
+
+        If the argument is an immutable buffer (most likely a string) then a copy
+        of the buffer is passed to the operating system and the return value is a
+        string of the same length containing whatever the operating system put in
+        the buffer.  The length of the arg buffer in this case is not allowed to
+        exceed 1024 bytes.
+
+        If the arg given is an integer or if none is specified, the result value is
+        an integer corresponding to the return value of the ioctl call in the C
+        code.
+        """
+        ...
     @overload
-    def ioctl(fd: FileDescriptorLike, request: int, arg: Buffer, mutate_flag: bool = True, /) -> Any: ...
-    def flock(fd: FileDescriptorLike, operation: int, /) -> None: ...
-    def lockf(fd: FileDescriptorLike, cmd: int, len: int = 0, start: int = 0, whence: int = 0, /) -> Any: ...
+    def ioctl(fd: FileDescriptorLike, request: int, arg: Buffer, mutate_flag: bool = True, /) -> Any:
+        """
+        Perform the operation `request` on file descriptor `fd`.
+
+        The values used for `request` are operating system dependent, and are available
+        as constants in the fcntl or termios library modules, using the same names as
+        used in the relevant C header files.
+
+        The argument `arg` is optional, and defaults to 0; it may be an int or a
+        buffer containing character data (most likely a string or an array).
+
+        If the argument is a mutable buffer (such as an array) and if the
+        mutate_flag argument (which is only allowed in this case) is true then the
+        buffer is (in effect) passed to the operating system and changes made by
+        the OS will be reflected in the contents of the buffer after the call has
+        returned.  The return value is the integer returned by the ioctl system
+        call.
+
+        If the argument is a mutable buffer and the mutable_flag argument is false,
+        the behavior is as if a string had been passed.
+
+        If the argument is an immutable buffer (most likely a string) then a copy
+        of the buffer is passed to the operating system and the return value is a
+        string of the same length containing whatever the operating system put in
+        the buffer.  The length of the arg buffer in this case is not allowed to
+        exceed 1024 bytes.
+
+        If the arg given is an integer or if none is specified, the result value is
+        an integer corresponding to the return value of the ioctl call in the C
+        code.
+        """
+        ...
+    def flock(fd: FileDescriptorLike, operation: int, /) -> None:
+        """
+        Perform the lock operation `operation` on file descriptor `fd`.
+
+        See the Unix manual page for flock(2) for details (On some systems, this
+        function is emulated using fcntl()).
+        """
+        ...
+    def lockf(fd: FileDescriptorLike, cmd: int, len: int = 0, start: int = 0, whence: int = 0, /) -> Any:
+        """
+        A wrapper around the fcntl() locking calls.
+
+        `fd` is the file descriptor of the file to lock or unlock, and operation is one
+        of the following values:
+
+            LOCK_UN - unlock
+            LOCK_SH - acquire a shared lock
+            LOCK_EX - acquire an exclusive lock
+
+        When operation is LOCK_SH or LOCK_EX, it can also be bitwise ORed with
+        LOCK_NB to avoid blocking on lock acquisition.  If LOCK_NB is used and the
+        lock cannot be acquired, an OSError will be raised and the exception will
+        have an errno attribute set to EACCES or EAGAIN (depending on the operating
+        system -- for portability, check for either value).
+
+        `len` is the number of bytes to lock, with the default meaning to lock to
+        EOF.  `start` is the byte offset, relative to `whence`, to that the lock
+        starts.  `whence` is as with fileobj.seek(), specifically:
+
+            0 - relative to the start of the file (SEEK_SET)
+            1 - relative to the current buffer position (SEEK_CUR)
+            2 - relative to the end of the file (SEEK_END)
+        """
+        ...

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

@@ -1,3 +1,25 @@
+"""
+This module provides access to the garbage collector for reference cycles.
+
+enable() -- Enable automatic garbage collection.
+disable() -- Disable automatic garbage collection.
+isenabled() -- Returns true if automatic collection is enabled.
+collect() -- Do a full collection right now.
+get_count() -- Return the current collection counts.
+get_stats() -- Return list of dictionaries containing per-generation stats.
+set_debug() -- Set debugging flags.
+get_debug() -- Get debugging flags.
+set_threshold() -- Set the collection thresholds.
+get_threshold() -- Return the current the collection thresholds.
+get_objects() -- Return a list of all objects tracked by the collector.
+is_tracked() -- Returns true if a given object is tracked.
+get_referrers() -- Return the list of objects that refer to an object.
+get_referents() -- Return the list of objects that an object refers to.
+freeze() -- Freeze all tracked objects and ignore them for future collections.
+unfreeze() -- Unfreeze all objects in the permanent generation.
+get_freeze_count() -- Return the number of objects in the permanent generation.
+"""
+
 import sys
 from collections.abc import Callable
 from typing import Any, Literal
@@ -14,24 +36,114 @@ _CallbackType: TypeAlias = Callable[[Literal["start", "stop"], dict[str, int]],
 callbacks: list[_CallbackType]
 garbage: list[Any]
 
-def collect(generation: int = 2) -> int: ...
-def disable() -> None: ...
-def enable() -> None: ...
-def get_count() -> tuple[int, int, int]: ...
-def get_debug() -> int: ...
-def get_objects(generation: int | None = None) -> list[Any]: ...
-def freeze() -> None: ...
-def unfreeze() -> None: ...
-def get_freeze_count() -> int: ...
-def get_referents(*objs: Any) -> list[Any]: ...
-def get_referrers(*objs: Any) -> list[Any]: ...
-def get_stats() -> list[dict[str, Any]]: ...
-def get_threshold() -> tuple[int, int, int]: ...
-def is_tracked(obj: Any, /) -> bool: ...
+def collect(generation: int = 2) -> int:
+    """
+    Run the garbage collector.
+
+    With no arguments, run a full collection.  The optional argument
+    may be an integer specifying which generation to collect.  A ValueError
+    is raised if the generation number is invalid.
+
+    The number of unreachable objects is returned.
+    """
+    ...
+def disable() -> None:
+    """Disable automatic garbage collection."""
+    ...
+def enable() -> None:
+    """Enable automatic garbage collection."""
+    ...
+def get_count() -> tuple[int, int, int]:
+    """Return a three-tuple of the current collection counts."""
+    ...
+def get_debug() -> int:
+    """Get the garbage collection debugging flags."""
+    ...
+def get_objects(generation: int | None = None) -> list[Any]:
+    """
+    Return a list of objects tracked by the collector (excluding the list returned).
+
+      generation
+        Generation to extract the objects from.
+
+    If generation is not None, return only the objects tracked by the collector
+    that are in that generation.
+    """
+    ...
+def freeze() -> None:
+    """
+    Freeze all current tracked objects and ignore them for future collections.
+
+    This can be used before a POSIX fork() call to make the gc copy-on-write friendly.
+    Note: collection before a POSIX fork() call may free pages for future allocation
+    which can cause copy-on-write.
+    """
+    ...
+def unfreeze() -> None:
+    """
+    Unfreeze all objects in the permanent generation.
+
+    Put all objects in the permanent generation back into oldest generation.
+    """
+    ...
+def get_freeze_count() -> int:
+    """Return the number of objects in the permanent generation."""
+    ...
+def get_referents(*objs: Any) -> list[Any]:
+    """
+    get_referents(*objs) -> list
+    Return the list of objects that are directly referred to by objs.
+    """
+    ...
+def get_referrers(*objs: Any) -> list[Any]:
+    """
+    get_referrers(*objs) -> list
+    Return the list of objects that directly refer to any of objs.
+    """
+    ...
+def get_stats() -> list[dict[str, Any]]:
+    """Return a list of dictionaries containing per-generation statistics."""
+    ...
+def get_threshold() -> tuple[int, int, int]:
+    """Return the current collection thresholds."""
+    ...
+def is_tracked(obj: Any, /) -> bool:
+    """
+    Returns true if the object is tracked by the garbage collector.
+
+    Simple atomic objects will return false.
+    """
+    ...
 
 if sys.version_info >= (3, 9):
-    def is_finalized(obj: Any, /) -> bool: ...
+    def is_finalized(obj: Any, /) -> bool:
+        """Returns true if the object has been already finalized by the GC."""
+        ...
+
+def isenabled() -> bool:
+    """Returns true if automatic garbage collection is enabled."""
+    ...
+def set_debug(flags: int, /) -> None:
+    """
+    Set the garbage collection debugging flags.
+
+      flags
+        An integer that can have the following bits turned on:
+          DEBUG_STATS - Print statistics during collection.
+          DEBUG_COLLECTABLE - Print collectable objects found.
+          DEBUG_UNCOLLECTABLE - Print unreachable but uncollectable objects
+            found.
+          DEBUG_SAVEALL - Save objects to gc.garbage rather than freeing them.
+          DEBUG_LEAK - Debug leaking programs (everything but STATS).
+
+    Debugging information is written to sys.stderr.
+    """
+    ...
+def set_threshold(threshold0: int, threshold1: int = ..., threshold2: int = ...) -> None:
+    """
+    set_threshold(threshold0, [threshold1, threshold2]) -> None
 
-def isenabled() -> bool: ...
-def set_debug(flags: int, /) -> None: ...
-def set_threshold(threshold0: int, threshold1: int = ..., threshold2: int = ...) -> None: ...
+    Sets the collection thresholds.  Setting threshold0 to zero disables
+    collection.
+    """
+    ...

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

@@ -1,3 +1,20 @@
+"""
+Access to the Unix group database.
+
+Group entries are reported as 4-tuples containing the following fields
+from the group database, in order:
+
+  gr_name   - name of the group
+  gr_passwd - group password (encrypted); often empty
+  gr_gid    - numeric ID of the group
+  gr_mem    - list of members
+
+The gid is an integer, name and password are strings.  (Note that most
+users are not explicitly listed as members of the groups they are in
+according to the password database.  Check both databases to get
+complete membership information.)
+"""
+
 import sys
 from _typeshed import structseq
 from typing import Any, Final, final
@@ -5,18 +22,52 @@ from typing import Any, Final, final
 if sys.platform != "win32":
     @final
     class struct_group(structseq[Any], tuple[str, str | None, int, list[str]]):
+        """
+        grp.struct_group: Results from getgr*() routines.
+
+        This object may be accessed either as a tuple of
+          (gr_name,gr_passwd,gr_gid,gr_mem)
+        or via the object attributes as named in the above tuple.
+        """
         if sys.version_info >= (3, 10):
             __match_args__: Final = ("gr_name", "gr_passwd", "gr_gid", "gr_mem")
 
         @property
-        def gr_name(self) -> str: ...
+        def gr_name(self) -> str:
+            """group name"""
+            ...
         @property
-        def gr_passwd(self) -> str | None: ...
+        def gr_passwd(self) -> str | None:
+            """password"""
+            ...
         @property
-        def gr_gid(self) -> int: ...
+        def gr_gid(self) -> int:
+            """group id"""
+            ...
         @property
-        def gr_mem(self) -> list[str]: ...
+        def gr_mem(self) -> list[str]:
+            """group members"""
+            ...
+
+    def getgrall() -> list[struct_group]:
+        """
+        Return a list of all available group entries, in arbitrary order.
+
+        An entry whose name starts with '+' or '-' represents an instruction
+        to use YP/NIS and may not be accessible via getgrnam or getgrgid.
+        """
+        ...
+    def getgrgid(id: int) -> struct_group:
+        """
+        Return the group database entry for the given numeric group ID.
+
+        If id is not valid, raise KeyError.
+        """
+        ...
+    def getgrnam(name: str) -> struct_group:
+        """
+        Return the group database entry for the given group name.
 
-    def getgrall() -> list[struct_group]: ...
-    def getgrgid(id: int) -> struct_group: ...
-    def getgrnam(name: str) -> struct_group: ...
+        If name is not valid, raise KeyError.
+        """
+        ...