basedpyright 1.12.6 → 1.13.0

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

@@ -1,3 +1,64 @@
+"""
+S_IFMT_: file type bits
+S_IFDIR: directory
+S_IFCHR: character device
+S_IFBLK: block device
+S_IFREG: regular file
+S_IFIFO: fifo (named pipe)
+S_IFLNK: symbolic link
+S_IFSOCK: socket file
+S_IFDOOR: door
+S_IFPORT: event port
+S_IFWHT: whiteout
+
+S_ISUID: set UID bit
+S_ISGID: set GID bit
+S_ENFMT: file locking enforcement
+S_ISVTX: sticky bit
+S_IREAD: Unix V7 synonym for S_IRUSR
+S_IWRITE: Unix V7 synonym for S_IWUSR
+S_IEXEC: Unix V7 synonym for S_IXUSR
+S_IRWXU: mask for owner permissions
+S_IRUSR: read by owner
+S_IWUSR: write by owner
+S_IXUSR: execute by owner
+S_IRWXG: mask for group permissions
+S_IRGRP: read by group
+S_IWGRP: write by group
+S_IXGRP: execute by group
+S_IRWXO: mask for others (not in group) permissions
+S_IROTH: read by others
+S_IWOTH: write by others
+S_IXOTH: execute by others
+
+UF_NODUMP: do not dump file
+UF_IMMUTABLE: file may not be changed
+UF_APPEND: file may only be appended to
+UF_OPAQUE: directory is opaque when viewed through a union stack
+UF_NOUNLINK: file may not be renamed or deleted
+UF_COMPRESSED: OS X: file is hfs-compressed
+UF_HIDDEN: OS X: file should not be displayed
+SF_ARCHIVED: file may be archived
+SF_IMMUTABLE: file may not be changed
+SF_APPEND: file may only be appended to
+SF_NOUNLINK: file may not be renamed or deleted
+SF_SNAPSHOT: file is a snapshot file
+
+ST_MODE
+ST_INO
+ST_DEV
+ST_NLINK
+ST_UID
+ST_GID
+ST_SIZE
+ST_ATIME
+ST_MTIME
+ST_CTIME
+
+FILE_ATTRIBUTE_*: Windows file attribute constants
+                   (only present on Windows)
+"""
+
 import sys
 from typing import Literal
 
@@ -64,19 +125,85 @@ UF_NODUMP: Literal[0x00000001]
 UF_NOUNLINK: Literal[0x00000010]
 UF_OPAQUE: Literal[0x00000008]
 
-def S_IMODE(mode: int, /) -> int: ...
-def S_IFMT(mode: int, /) -> int: ...
-def S_ISBLK(mode: int, /) -> bool: ...
-def S_ISCHR(mode: int, /) -> bool: ...
-def S_ISDIR(mode: int, /) -> bool: ...
-def S_ISDOOR(mode: int, /) -> bool: ...
-def S_ISFIFO(mode: int, /) -> bool: ...
-def S_ISLNK(mode: int, /) -> bool: ...
-def S_ISPORT(mode: int, /) -> bool: ...
-def S_ISREG(mode: int, /) -> bool: ...
-def S_ISSOCK(mode: int, /) -> bool: ...
-def S_ISWHT(mode: int, /) -> bool: ...
-def filemode(mode: int, /) -> str: ...
+def S_IMODE(mode: int, /) -> int:
+    """Return the portion of the file's mode that can be set by os.chmod()."""
+    ...
+def S_IFMT(mode: int, /) -> int:
+    """Return the portion of the file's mode that describes the file type."""
+    ...
+def S_ISBLK(mode: int, /) -> bool:
+    """
+    S_ISBLK(mode) -> bool
+
+    Return True if mode is from a block special device file.
+    """
+    ...
+def S_ISCHR(mode: int, /) -> bool:
+    """
+    S_ISCHR(mode) -> bool
+
+    Return True if mode is from a character special device file.
+    """
+    ...
+def S_ISDIR(mode: int, /) -> bool:
+    """
+    S_ISDIR(mode) -> bool
+
+    Return True if mode is from a directory.
+    """
+    ...
+def S_ISDOOR(mode: int, /) -> bool:
+    """
+    S_ISDOOR(mode) -> bool
+
+    Return True if mode is from a door.
+    """
+    ...
+def S_ISFIFO(mode: int, /) -> bool:
+    """
+    S_ISFIFO(mode) -> bool
+
+    Return True if mode is from a FIFO (named pipe).
+    """
+    ...
+def S_ISLNK(mode: int, /) -> bool:
+    """
+    S_ISLNK(mode) -> bool
+
+    Return True if mode is from a symbolic link.
+    """
+    ...
+def S_ISPORT(mode: int, /) -> bool:
+    """
+    S_ISPORT(mode) -> bool
+
+    Return True if mode is from an event port.
+    """
+    ...
+def S_ISREG(mode: int, /) -> bool:
+    """
+    S_ISREG(mode) -> bool
+
+    Return True if mode is from a regular file.
+    """
+    ...
+def S_ISSOCK(mode: int, /) -> bool:
+    """
+    S_ISSOCK(mode) -> bool
+
+    Return True if mode is from a socket.
+    """
+    ...
+def S_ISWHT(mode: int, /) -> bool:
+    """
+    S_ISWHT(mode) -> bool
+
+    Return True if mode is from a whiteout.
+    """
+    ...
+def filemode(mode: int, /) -> str:
+    """Convert a file's mode to a string of the form '-rwxrwxrwx'"""
+    ...
 
 if sys.platform == "win32":
     IO_REPARSE_TAG_SYMLINK: int

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

@@ -1,3 +1,8 @@
+"""
+This module provides primitive operations to write multi-threaded programs.
+The 'threading' module provides a more convenient interface.
+"""
+
 import sys
 from _typeshed import structseq
 from collections.abc import Callable
@@ -10,50 +15,238 @@ _Ts = TypeVarTuple("_Ts")
 
 error = RuntimeError
 
-def _count() -> int: ...
+def _count() -> int:
+    """
+    _count() -> integer
+
+    Return the number of currently running Python threads, excluding
+    the main thread. The returned number comprises all threads created
+    through `start_new_thread()` as well as `threading.Thread`, and not
+    yet finished.
+
+    This function is meant for internal and specialized purposes only.
+    In most applications `threading.enumerate()` should be used instead.
+    """
+    ...
 @final
 class LockType:
-    def acquire(self, blocking: bool = ..., timeout: float = ...) -> bool: ...
-    def release(self) -> None: ...
-    def locked(self) -> bool: ...
-    def __enter__(self) -> bool: ...
+    """
+    A lock object is a synchronization primitive.  To create a lock,
+    call threading.Lock().  Methods are:
+
+    acquire() -- lock the lock, possibly blocking until it can be obtained
+    release() -- unlock of the lock
+    locked() -- test whether the lock is currently locked
+
+    A lock is not owned by the thread that locked it; another thread may
+    unlock it.  A thread attempting to lock a lock that it has already locked
+    will block until another thread unlocks it.  Deadlocks may ensue.
+    """
+    def acquire(self, blocking: bool = ..., timeout: float = ...) -> bool:
+        """
+        acquire(blocking=True, timeout=-1) -> bool
+        (acquire_lock() is an obsolete synonym)
+
+        Lock the lock.  Without argument, this blocks if the lock is already
+        locked (even by the same thread), waiting for another thread to release
+        the lock, and return True once the lock is acquired.
+        With an argument, this will only block if the argument is true,
+        and the return value reflects whether the lock is acquired.
+        The blocking operation is interruptible.
+        """
+        ...
+    def release(self) -> None:
+        """
+        release()
+        (release_lock() is an obsolete synonym)
+
+        Release the lock, allowing another thread that is blocked waiting for
+        the lock to acquire the lock.  The lock must be in the locked state,
+        but it needn't be locked by the same thread that unlocks it.
+        """
+        ...
+    def locked(self) -> bool:
+        """
+        locked() -> bool
+        (locked_lock() is an obsolete synonym)
+
+        Return whether the lock is in the locked state.
+        """
+        ...
+    def __enter__(self) -> bool:
+        """
+        acquire(blocking=True, timeout=-1) -> bool
+        (acquire_lock() is an obsolete synonym)
+
+        Lock the lock.  Without argument, this blocks if the lock is already
+        locked (even by the same thread), waiting for another thread to release
+        the lock, and return True once the lock is acquired.
+        With an argument, this will only block if the argument is true,
+        and the return value reflects whether the lock is acquired.
+        The blocking operation is interruptible.
+        """
+        ...
     def __exit__(
         self, type: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None
-    ) -> None: ...
+    ) -> None:
+        """
+        release()
+        (release_lock() is an obsolete synonym)
+
+        Release the lock, allowing another thread that is blocked waiting for
+        the lock to acquire the lock.  The lock must be in the locked state,
+        but it needn't be locked by the same thread that unlocks it.
+        """
+        ...
 
 @overload
-def start_new_thread(function: Callable[[Unpack[_Ts]], object], args: tuple[Unpack[_Ts]]) -> int: ...
+def start_new_thread(function: Callable[[Unpack[_Ts]], object], args: tuple[Unpack[_Ts]]) -> int:
+    """
+    start_new_thread(function, args[, kwargs])
+    (start_new() is an obsolete synonym)
+
+    Start a new thread and return its identifier.  The thread will call the
+    function with positional arguments from the tuple args and keyword arguments
+    taken from the optional dictionary kwargs.  The thread exits when the
+    function returns; the return value is ignored.  The thread will also exit
+    when the function raises an unhandled exception; a stack trace will be
+    printed unless the exception is SystemExit.
+    """
+    ...
 @overload
-def start_new_thread(function: Callable[..., object], args: tuple[Any, ...], kwargs: dict[str, Any]) -> int: ...
-def interrupt_main() -> None: ...
-def exit() -> NoReturn: ...
-def allocate_lock() -> LockType: ...
-def get_ident() -> int: ...
-def stack_size(size: int = ...) -> int: ...
+def start_new_thread(function: Callable[..., object], args: tuple[Any, ...], kwargs: dict[str, Any]) -> int:
+    """
+    start_new_thread(function, args[, kwargs])
+    (start_new() is an obsolete synonym)
+
+    Start a new thread and return its identifier.  The thread will call the
+    function with positional arguments from the tuple args and keyword arguments
+    taken from the optional dictionary kwargs.  The thread exits when the
+    function returns; the return value is ignored.  The thread will also exit
+    when the function raises an unhandled exception; a stack trace will be
+    printed unless the exception is SystemExit.
+    """
+    ...
+def interrupt_main() -> None:
+    """
+    interrupt_main()
+
+    Raise a KeyboardInterrupt in the main thread.
+    A subthread can use this function to interrupt the main thread.
+    """
+    ...
+def exit() -> NoReturn:
+    """
+    exit()
+    (exit_thread() is an obsolete synonym)
+
+    This is synonymous to ``raise SystemExit''.  It will cause the current
+    thread to exit silently unless the exception is caught.
+    """
+    ...
+def allocate_lock() -> LockType:
+    """
+    allocate_lock() -> lock object
+    (allocate() is an obsolete synonym)
+
+    Create a new lock object. See help(type(threading.Lock())) for
+    information about locks.
+    """
+    ...
+def get_ident() -> int:
+    """
+    get_ident() -> integer
+
+    Return a non-zero integer that uniquely identifies the current thread
+    amongst other threads that exist simultaneously.
+    This may be used to identify per-thread resources.
+    Even though on some platforms threads identities may appear to be
+    allocated consecutive numbers starting at 1, this behavior should not
+    be relied upon, and the number should be seen purely as a magic cookie.
+    A thread's identity may be reused for another thread after it exits.
+    """
+    ...
+def stack_size(size: int = ...) -> int:
+    """
+    stack_size([size]) -> size
+
+    Return the thread stack size used when creating new threads.  The
+    optional size argument specifies the stack size (in bytes) to be used
+    for subsequently created threads, and must be 0 (use platform or
+    configured default) or a positive integer value of at least 32,768 (32k).
+    If changing the thread stack size is unsupported, a ThreadError
+    exception is raised.  If the specified size is invalid, a ValueError
+    exception is raised, and the stack size is unmodified.  32k bytes
+     currently the minimum supported stack size value to guarantee
+    sufficient stack space for the interpreter itself.
+
+    Note that some platforms may have particular restrictions on values for
+    the stack size, such as requiring a minimum stack size larger than 32 KiB or
+    requiring allocation in multiples of the system memory page size
+    - platform documentation should be referred to for more information
+    (4 KiB pages are common; using multiples of 4096 for the stack size is
+    the suggested approach in the absence of more specific information).
+    """
+    ...
 
 TIMEOUT_MAX: float
 
-def get_native_id() -> int: ...  # only available on some platforms
+def get_native_id() -> int:
+    """
+    get_native_id() -> integer
+
+    Return a non-negative integer identifying the thread as reported
+    by the OS (kernel). This may be used to uniquely identify a
+    particular thread within a system.
+    """
+    ...
 @final
 class _ExceptHookArgs(structseq[Any], tuple[type[BaseException], BaseException | None, TracebackType | None, Thread | None]):
+    """
+    ExceptHookArgs
+
+    Type used to pass arguments to threading.excepthook.
+    """
     if sys.version_info >= (3, 10):
         __match_args__: Final = ("exc_type", "exc_value", "exc_traceback", "thread")
 
     @property
-    def exc_type(self) -> type[BaseException]: ...
+    def exc_type(self) -> type[BaseException]:
+        """Exception type"""
+        ...
     @property
-    def exc_value(self) -> BaseException | None: ...
+    def exc_value(self) -> BaseException | None:
+        """Exception value"""
+        ...
     @property
-    def exc_traceback(self) -> TracebackType | None: ...
+    def exc_traceback(self) -> TracebackType | None:
+        """Exception traceback"""
+        ...
     @property
-    def thread(self) -> Thread | None: ...
+    def thread(self) -> Thread | None:
+        """Thread"""
+        ...
 
 _excepthook: Callable[[_ExceptHookArgs], Any]
 
 if sys.version_info >= (3, 12):
-    def daemon_threads_allowed() -> bool: ...
+    def daemon_threads_allowed() -> bool:
+        """
+        daemon_threads_allowed()
+
+        Return True if daemon threads are allowed in the current interpreter,
+        and False otherwise.
+        """
+        ...
 
 class _local:
-    def __getattribute__(self, name: str, /) -> Any: ...
-    def __setattr__(self, name: str, value: Any, /) -> None: ...
-    def __delattr__(self, name: str, /) -> None: ...
+    """Thread-local data"""
+    def __getattribute__(self, name: str, /) -> Any:
+        """Return getattr(self, name)."""
+        ...
+    def __setattr__(self, name: str, value: Any, /) -> None:
+        """Implement setattr(self, name, value)."""
+        ...
+    def __delattr__(self, name: str, /) -> None:
+        """Implement delattr(self, name)."""
+        ...

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

@@ -17,16 +17,32 @@ from typing import Any, ClassVar, Literal, final
 @final
 class Tcl_Obj:
     @property
-    def string(self) -> str: ...
+    def string(self) -> str:
+        """the string representation of this object, either as str or bytes"""
+        ...
     @property
-    def typename(self) -> str: ...
+    def typename(self) -> str:
+        """name of the Tcl type"""
+        ...
     __hash__: ClassVar[None]  # type: ignore[assignment]
-    def __eq__(self, value, /): ...
-    def __ge__(self, value, /): ...
-    def __gt__(self, value, /): ...
-    def __le__(self, value, /): ...
-    def __lt__(self, value, /): ...
-    def __ne__(self, value, /): ...
+    def __eq__(self, value, /):
+        """Return self==value."""
+        ...
+    def __ge__(self, value, /):
+        """Return self>=value."""
+        ...
+    def __gt__(self, value, /):
+        """Return self>value."""
+        ...
+    def __le__(self, value, /):
+        """Return self<=value."""
+        ...
+    def __lt__(self, value, /):
+        """Return self<value."""
+        ...
+    def __ne__(self, value, /):
+        """Return self!=value."""
+        ...
 
 class TclError(Exception): ...
 
@@ -116,6 +132,23 @@ def create(
     sync: bool = False,
     use: str | None = None,
     /,
-): ...
-def getbusywaitinterval(): ...
-def setbusywaitinterval(new_val, /): ...
+):
+    """
+    wantTk
+      if false, then Tk_Init() doesn't get called
+    sync
+      if true, then pass -sync to wish
+    use
+      if not None, then pass -use to wish
+    """
+    ...
+def getbusywaitinterval():
+    """Return the current busy-wait interval between successive calls to Tcl_DoOneEvent in a threaded Python interpreter."""
+    ...
+def setbusywaitinterval(new_val, /):
+    """
+    Set the busy-wait interval in milliseconds between successive calls to Tcl_DoOneEvent in a threaded Python interpreter.
+
+    It should be set to a divisor of the maximum time between frames in an animation.
+    """
+    ...

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

@@ -1,17 +1,78 @@
+"""Debug module to trace memory blocks allocated by Python."""
+
 import sys
 from collections.abc import Sequence
 from tracemalloc import _FrameTuple, _TraceTuple
 
-def _get_object_traceback(obj: object, /) -> Sequence[_FrameTuple] | None: ...
-def _get_traces() -> Sequence[_TraceTuple]: ...
-def clear_traces() -> None: ...
-def get_traceback_limit() -> int: ...
-def get_traced_memory() -> tuple[int, int]: ...
-def get_tracemalloc_memory() -> int: ...
-def is_tracing() -> bool: ...
+def _get_object_traceback(obj: object, /) -> Sequence[_FrameTuple] | None:
+    """
+    Get the traceback where the Python object obj was allocated.
+
+    Return a tuple of (filename: str, lineno: int) tuples.
+    Return None if the tracemalloc module is disabled or did not
+    trace the allocation of the object.
+    """
+    ...
+def _get_traces() -> Sequence[_TraceTuple]:
+    """
+    Get traces of all memory blocks allocated by Python.
+
+    Return a list of (size: int, traceback: tuple) tuples.
+    traceback is a tuple of (filename: str, lineno: int) tuples.
+
+    Return an empty list if the tracemalloc module is disabled.
+    """
+    ...
+def clear_traces() -> None:
+    """Clear traces of memory blocks allocated by Python."""
+    ...
+def get_traceback_limit() -> int:
+    """
+    Get the maximum number of frames stored in the traceback of a trace.
+
+    By default, a trace of an allocated memory block only stores
+    the most recent frame: the limit is 1.
+    """
+    ...
+def get_traced_memory() -> tuple[int, int]:
+    """
+    Get the current size and peak size of memory blocks traced by tracemalloc.
+
+    Returns a tuple: (current: int, peak: int).
+    """
+    ...
+def get_tracemalloc_memory() -> int:
+    """
+    Get the memory usage in bytes of the tracemalloc module.
+
+    This memory is used internally to trace memory allocations.
+    """
+    ...
+def is_tracing() -> bool:
+    """Return True if the tracemalloc module is tracing Python memory allocations."""
+    ...
 
 if sys.version_info >= (3, 9):
-    def reset_peak() -> None: ...
+    def reset_peak() -> None:
+        """
+        Set the peak size of memory blocks traced by tracemalloc to the current size.
+
+        Do nothing if the tracemalloc module is not tracing memory allocations.
+        """
+        ...
+
+def start(nframe: int = 1, /) -> None:
+    """
+    Start tracing Python memory allocations.
+
+    Also set the maximum number of frames stored in the traceback of a
+    trace to nframe.
+    """
+    ...
+def stop() -> None:
+    """
+    Stop tracing Python memory allocations.
 
-def start(nframe: int = 1, /) -> None: ...
-def stop() -> None: ...
+    Also clear traces of memory blocks allocated by Python.
+    """
+    ...

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

@@ -1,3 +1,8 @@
+"""
+_warnings provides basic warning filtering support.
+It is a helper module to speed up interpreter start-up.
+"""
+
 import sys
 from typing import Any, overload
 
@@ -14,7 +19,24 @@ if sys.version_info >= (3, 12):
         source: Any | None = None,
         *,
         skip_file_prefixes: tuple[str, ...] = (),
-    ) -> None: ...
+    ) -> None:
+        """
+        Issue a warning, or maybe ignore it or raise an exception.
+
+        message
+          Text of the warning message.
+        category
+          The Warning category subclass. Defaults to UserWarning.
+        stacklevel
+          How far up the call stack to make this warning appear. A value of 2 for
+          example attributes the warning to the caller of the code calling warn().
+        source
+          If supplied, the destroyed object which emitted a ResourceWarning
+        skip_file_prefixes
+          An optional tuple of module filename prefixes indicating frames to skip
+          during stacklevel computations for stack frame attribution.
+        """
+        ...
     @overload
     def warn(
         message: Warning,
@@ -23,13 +45,34 @@ if sys.version_info >= (3, 12):
         source: Any | None = None,
         *,
         skip_file_prefixes: tuple[str, ...] = (),
-    ) -> None: ...
+    ) -> None:
+        """
+        Issue a warning, or maybe ignore it or raise an exception.
+
+        message
+          Text of the warning message.
+        category
+          The Warning category subclass. Defaults to UserWarning.
+        stacklevel
+          How far up the call stack to make this warning appear. A value of 2 for
+          example attributes the warning to the caller of the code calling warn().
+        source
+          If supplied, the destroyed object which emitted a ResourceWarning
+        skip_file_prefixes
+          An optional tuple of module filename prefixes indicating frames to skip
+          during stacklevel computations for stack frame attribution.
+        """
+        ...
 
 else:
     @overload
-    def warn(message: str, category: type[Warning] | None = None, stacklevel: int = 1, source: Any | None = None) -> None: ...
+    def warn(message: str, category: type[Warning] | None = None, stacklevel: int = 1, source: Any | None = None) -> None:
+        """Issue a warning, or maybe ignore it or raise an exception."""
+        ...
     @overload
-    def warn(message: Warning, category: Any = None, stacklevel: int = 1, source: Any | None = None) -> None: ...
+    def warn(message: Warning, category: Any = None, stacklevel: int = 1, source: Any | None = None) -> None:
+        """Issue a warning, or maybe ignore it or raise an exception."""
+        ...
 
 @overload
 def warn_explicit(
@@ -41,7 +84,9 @@ def warn_explicit(
     registry: dict[str | tuple[str, type[Warning], int], int] | None = ...,
     module_globals: dict[str, Any] | None = ...,
     source: Any | None = ...,
-) -> None: ...
+) -> None:
+    """Low-level interface to warnings functionality."""
+    ...
 @overload
 def warn_explicit(
     message: Warning,
@@ -52,4 +97,6 @@ def warn_explicit(
     registry: dict[str | tuple[str, type[Warning], int], int] | None = ...,
     module_globals: dict[str, Any] | None = ...,
     source: Any | None = ...,
-) -> None: ...
+) -> None:
+    """Low-level interface to warnings functionality."""
+    ...