basedpyright 1.18.4 → 1.19.0

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

@@ -1,50 +1,204 @@
-import types
-from collections.abc import Callable, Mapping
-from typing import Final, Literal, SupportsIndex
-from typing_extensions import TypeAlias
-
-_Configs: TypeAlias = Literal["default", "isolated", "legacy", "empty", ""]
-
-class InterpreterError(Exception): ...
-class InterpreterNotFoundError(InterpreterError): ...
-class NotShareableError(Exception): ...
-
-class CrossInterpreterBufferView:
-    def __buffer__(self, flags: int, /) -> memoryview: ...
-
-def new_config(name: _Configs = "isolated", /, **overides: object) -> types.SimpleNamespace: ...
-def create(config: types.SimpleNamespace | _Configs | None = "isolated", *, reqrefs: bool = False) -> int: ...
-def destroy(id: SupportsIndex, *, restrict: bool = False) -> None: ...
-def list_all(*, require_ready: bool) -> list[tuple[int, int]]: ...
-def get_current() -> tuple[int, int]: ...
-def get_main() -> tuple[int, int]: ...
-def is_running(id: SupportsIndex, *, restrict: bool = False) -> bool: ...
-def get_config(id: SupportsIndex, *, restrict: bool = False) -> types.SimpleNamespace: ...
-def whence(id: SupportsIndex) -> int: ...
-def exec(id: SupportsIndex, code: str, shared: bool | None = None, *, restrict: bool = False) -> None: ...
-def call(
-    id: SupportsIndex,
-    callable: Callable[..., object],
-    args: tuple[object, ...] | None = None,
-    kwargs: dict[str, object] | None = None,
-    *,
-    restrict: bool = False,
-) -> object: ...
-def run_string(
-    id: SupportsIndex, script: str | types.CodeType | Callable[[], object], shared: bool | None = None, *, restrict: bool = False
-) -> None: ...
-def run_func(
-    id: SupportsIndex, func: types.CodeType | Callable[[], object], shared: bool | None = None, *, restrict: bool = False
-) -> None: ...
-def set___main___attrs(id: SupportsIndex, updates: Mapping[str, object], *, restrict: bool = False) -> None: ...
-def incref(id: SupportsIndex, *, implieslink: bool = False, restrict: bool = False) -> None: ...
-def decref(id: SupportsIndex, *, restrict: bool = False) -> None: ...
-def is_shareable(obj: object) -> bool: ...
-def capture_exception(exc: BaseException | None = None) -> types.SimpleNamespace: ...
-
-WHENCE_UNKNOWN: Final = 0
-WHENCE_RUNTIME: Final = 1
-WHENCE_LEGACY_CAPI: Final = 2
-WHENCE_CAPI: Final = 3
-WHENCE_XI: Final = 4
-WHENCE_STDLIB: Final = 5
+"""
+This module provides primitive operations to manage Python interpreters.
+The 'interpreters' module provides a more convenient interface.
+"""
+
+import types
+from collections.abc import Callable, Mapping
+from typing import Final, Literal, SupportsIndex
+from typing_extensions import TypeAlias
+
+_Configs: TypeAlias = Literal["default", "isolated", "legacy", "empty", ""]
+
+class InterpreterError(Exception):
+    """A cross-interpreter operation failed"""
+    ...
+class InterpreterNotFoundError(InterpreterError):
+    """An interpreter was not found"""
+    ...
+class NotShareableError(Exception): ...
+
+class CrossInterpreterBufferView:
+    def __buffer__(self, flags: int, /) -> memoryview:
+        """Return a buffer object that exposes the underlying memory of the object."""
+        ...
+
+def new_config(name: _Configs = "isolated", /, **overides: object) -> types.SimpleNamespace:
+    """
+    new_config(name='isolated', /, **overrides) -> type.SimpleNamespace
+
+    Return a representation of a new PyInterpreterConfig.
+
+    The name determines the initial values of the config.  Supported named
+    configs are: default, isolated, legacy, and empty.
+
+    Any keyword arguments are set on the corresponding config fields,
+    overriding the initial values.
+    """
+    ...
+def create(config: types.SimpleNamespace | _Configs | None = "isolated", *, reqrefs: bool = False) -> int:
+    """
+    create([config], *, reqrefs=False) -> ID
+
+    Create a new interpreter and return a unique generated ID.
+
+    The caller is responsible for destroying the interpreter before exiting,
+    typically by using _interpreters.destroy().  This can be managed 
+    automatically by passing "reqrefs=True" and then using _incref() and
+    _decref()` appropriately.
+
+    "config" must be a valid interpreter config or the name of a
+    predefined config ("isolated" or "legacy").  The default
+    is "isolated".
+    """
+    ...
+def destroy(id: SupportsIndex, *, restrict: bool = False) -> None:
+    """
+    destroy(id, *, restrict=False)
+
+    Destroy the identified interpreter.
+
+    Attempting to destroy the current interpreter raises InterpreterError.
+    So does an unrecognized ID.
+    """
+    ...
+def list_all(*, require_ready: bool) -> list[tuple[int, int]]:
+    """
+    list_all() -> [(ID, whence)]
+
+    Return a list containing the ID of every existing interpreter.
+    """
+    ...
+def get_current() -> tuple[int, int]:
+    """
+    get_current() -> (ID, whence)
+
+    Return the ID of current interpreter.
+    """
+    ...
+def get_main() -> tuple[int, int]:
+    """
+    get_main() -> (ID, whence)
+
+    Return the ID of main interpreter.
+    """
+    ...
+def is_running(id: SupportsIndex, *, restrict: bool = False) -> bool:
+    """
+    is_running(id, *, restrict=False) -> bool
+
+    Return whether or not the identified interpreter is running.
+    """
+    ...
+def get_config(id: SupportsIndex, *, restrict: bool = False) -> types.SimpleNamespace:
+    """
+    get_config(id, *, restrict=False) -> types.SimpleNamespace
+
+    Return a representation of the config used to initialize the interpreter.
+    """
+    ...
+def whence(id: SupportsIndex) -> int:
+    """
+    whence(id) -> int
+
+    Return an identifier for where the interpreter was created.
+    """
+    ...
+def exec(id: SupportsIndex, code: str, shared: bool | None = None, *, restrict: bool = False) -> None:
+    """
+    exec(id, code, shared=None, *, restrict=False)
+
+    Execute the provided code in the identified interpreter.
+    This is equivalent to running the builtin exec() under the target
+    interpreter, using the __dict__ of its __main__ module as both
+    globals and locals.
+
+    "code" may be a string containing the text of a Python script.
+
+    Functions (and code objects) are also supported, with some restrictions.
+    The code/function must not take any arguments or be a closure
+    (i.e. have cell vars).  Methods and other callables are not supported.
+
+    If a function is provided, its code object is used and all its state
+    is ignored, including its __globals__ dict.
+    """
+    ...
+def call(
+    id: SupportsIndex,
+    callable: Callable[..., object],
+    args: tuple[object, ...] | None = None,
+    kwargs: dict[str, object] | None = None,
+    *,
+    restrict: bool = False,
+) -> object:
+    """
+    call(id, callable, args=None, kwargs=None, *, restrict=False)
+
+    Call the provided object in the identified interpreter.
+    Pass the given args and kwargs, if possible.
+
+    "callable" may be a plain function with no free vars that takes
+    no arguments.
+
+    The function's code object is used and all its state
+    is ignored, including its __globals__ dict.
+    """
+    ...
+def run_string(
+    id: SupportsIndex, script: str | types.CodeType | Callable[[], object], shared: bool | None = None, *, restrict: bool = False
+) -> None:
+    """
+    run_string(id, script, shared=None, *, restrict=False)
+
+    Execute the provided string in the identified interpreter.
+
+    (See _interpreters.exec().
+    """
+    ...
+def run_func(
+    id: SupportsIndex, func: types.CodeType | Callable[[], object], shared: bool | None = None, *, restrict: bool = False
+) -> None:
+    """
+    run_func(id, func, shared=None, *, restrict=False)
+
+    Execute the body of the provided function in the identified interpreter.
+    Code objects are also supported.  In both cases, closures and args
+    are not supported.  Methods and other callables are not supported either.
+
+    (See _interpreters.exec().
+    """
+    ...
+def set___main___attrs(id: SupportsIndex, updates: Mapping[str, object], *, restrict: bool = False) -> None:
+    """
+    set___main___attrs(id, ns, *, restrict=False)
+
+    Bind the given attributes in the interpreter's __main__ module.
+    """
+    ...
+def incref(id: SupportsIndex, *, implieslink: bool = False, restrict: bool = False) -> None: ...
+def decref(id: SupportsIndex, *, restrict: bool = False) -> None: ...
+def is_shareable(obj: object) -> bool:
+    """
+    is_shareable(obj) -> bool
+
+    Return True if the object's data may be shared between interpreters and
+    False otherwise.
+    """
+    ...
+def capture_exception(exc: BaseException | None = None) -> types.SimpleNamespace:
+    """
+    capture_exception(exc=None) -> types.SimpleNamespace
+
+    Return a snapshot of an exception.  If "exc" is None
+    then the current exception, if any, is used (but not cleared).
+
+    The returned snapshot is the same as what _interpreters.exec() returns.
+    """
+    ...
+
+WHENCE_UNKNOWN: Final = 0
+WHENCE_RUNTIME: Final = 1
+WHENCE_LEGACY_CAPI: Final = 2
+WHENCE_CAPI: Final = 3
+WHENCE_XI: Final = 4
+WHENCE_STDLIB: Final = 5

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

@@ -5,7 +5,7 @@ from typing import Any, final
 
 @final
 class make_encoder:
-    """_iterencode(obj, _current_indent_level) -> iterable"""
+    """Encoder(markers, default, encoder, indent, key_separator, item_separator, sort_keys, skipkeys, allow_nan)"""
     @property
     def sort_keys(self) -> bool:
         """sort_keys"""

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

@@ -1198,11 +1198,7 @@ def ntohl(x: int, /) -> int:
     """
     ...
 def ntohs(x: int, /) -> int:
-    """
-    ntohs(integer) -> integer
-
-    Convert a 16-bit unsigned integer from network to host byte order.
-    """
+    """Convert a 16-bit unsigned integer from network to host byte order."""
     ...
 def htonl(x: int, /) -> int:
     """
@@ -1212,26 +1208,13 @@ def htonl(x: int, /) -> int:
     """
     ...
 def htons(x: int, /) -> int:
-    """
-    htons(integer) -> integer
-
-    Convert a 16-bit unsigned integer from host to network byte order.
-    """
+    """Convert a 16-bit unsigned integer from host to network byte order."""
     ...
 def inet_aton(ip_addr: str, /) -> bytes:
-    """
-    inet_aton(string) -> bytes giving packed 32-bit IP representation
-
-    Convert an IP address in string format (123.45.67.89) to the 32-bit packed
-    binary format used in low-level network functions.
-    """
+    """Convert an IP address in string format (123.45.67.89) to the 32-bit packed binary format used in low-level network functions."""
     ...
 def inet_ntoa(packed_ip: ReadableBuffer, /) -> str:
-    """
-    inet_ntoa(packed_ip) -> ip_address_string
-
-    Convert an IP address from 32-bit packed binary format to string format
-    """
+    """Convert an IP address from 32-bit packed binary format to string format."""
     ...
 def inet_pton(address_family: int, ip_string: str, /) -> bytes:
     """
@@ -1321,11 +1304,7 @@ def if_nameindex() -> list[tuple[int, str]]:
     """
     ...
 def if_nametoindex(oname: str, /) -> int:
-    """
-    if_nametoindex(if_name)
-
-    Returns the interface index corresponding to the interface name if_name.
-    """
+    """Returns the interface index corresponding to the interface name if_name."""
     ...
 def if_indextoname(index: int, /) -> str:
     """

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

@@ -239,10 +239,15 @@ if sys.version_info >= (3, 12):
         autocommit: bool = ...,
     ) -> Connection:
         """
-        Opens a connection to the SQLite database file database.
+        Open a connection to the SQLite database file 'database'.
 
-        You can use ":memory:" to open a database connection to a database that resides
-        in RAM instead of on disk.
+        You can use ":memory:" to open a database connection to a database that
+        resides in RAM instead of on disk.
+
+        Note: Passing more than 1 positional argument to _sqlite3.connect() is
+        deprecated. Parameters 'timeout', 'detect_types', 'isolation_level',
+        'check_same_thread', 'factory', 'cached_statements' and 'uri' will
+        become keyword-only parameters in Python 3.15.
         """
         ...
     @overload
@@ -259,10 +264,15 @@ if sys.version_info >= (3, 12):
         autocommit: bool = ...,
     ) -> _ConnectionT:
         """
-        Opens a connection to the SQLite database file database.
+        Open a connection to the SQLite database file 'database'.
 
-        You can use ":memory:" to open a database connection to a database that resides
-        in RAM instead of on disk.
+        You can use ":memory:" to open a database connection to a database that
+        resides in RAM instead of on disk.
+
+        Note: Passing more than 1 positional argument to _sqlite3.connect() is
+        deprecated. Parameters 'timeout', 'detect_types', 'isolation_level',
+        'check_same_thread', 'factory', 'cached_statements' and 'uri' will
+        become keyword-only parameters in Python 3.15.
         """
         ...
     @overload
@@ -279,10 +289,15 @@ if sys.version_info >= (3, 12):
         autocommit: bool = ...,
     ) -> _ConnectionT:
         """
-        Opens a connection to the SQLite database file database.
+        Open a connection to the SQLite database file 'database'.
 
-        You can use ":memory:" to open a database connection to a database that resides
-        in RAM instead of on disk.
+        You can use ":memory:" to open a database connection to a database that
+        resides in RAM instead of on disk.
+
+        Note: Passing more than 1 positional argument to _sqlite3.connect() is
+        deprecated. Parameters 'timeout', 'detect_types', 'isolation_level',
+        'check_same_thread', 'factory', 'cached_statements' and 'uri' will
+        become keyword-only parameters in Python 3.15.
         """
         ...
 

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

@@ -31,18 +31,29 @@ S_IROTH: read by others
 S_IWOTH: write by others
 S_IXOTH: execute by others
 
+UF_SETTABLE: mask of owner changable flags
 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
+UF_COMPRESSED: macOS: file is hfs-compressed
+UF_TRACKED: used for dealing with document IDs
+UF_DATAVAULT: entitlement required for reading and writing
+UF_HIDDEN: macOS: file should not be displayed
+SF_SETTABLE: mask of super user changeable flags
 SF_ARCHIVED: file may be archived
 SF_IMMUTABLE: file may not be changed
 SF_APPEND: file may only be appended to
+SF_RESTRICTED: entitlement required for writing
 SF_NOUNLINK: file may not be renamed or deleted
 SF_SNAPSHOT: file is a snapshot file
+SF_FIRMLINK: file is a firmlink
+SF_DATALESS: file is a dataless object
+
+On macOS:
+SF_SUPPORTED: mask of super user supported flags
+SF_SYNTHETIC: mask of read-only synthetic flags
 
 ST_MODE
 ST_INO

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

@@ -18,8 +18,6 @@ error = RuntimeError
 
 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
@@ -45,9 +43,6 @@ class LockType:
     """
     def acquire(self, blocking: bool = True, timeout: float = -1) -> 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.
@@ -58,77 +53,30 @@ class LockType:
         ...
     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.
-        """
+        """Return whether the lock is in the locked state."""
         ...
     def acquire_lock(self, blocking: bool = True, timeout: float = -1) -> 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.
-        """
+        """An obsolete synonym of acquire()."""
         ...
     def release_lock(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.
-        """
+        """An obsolete synonym of release()."""
         ...
     def locked_lock(self) -> bool:
-        """
-        locked() -> bool
-        (locked_lock() is an obsolete synonym)
-
-        Return whether the lock is in the locked state.
-        """
+        """An obsolete synonym of locked()."""
         ...
     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.
-        """
+        """Lock the lock."""
         ...
     def __exit__(
         self, type: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | 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.
-        """
+        """Release the lock."""
         ...
 
 if sys.version_info >= (3, 13):
@@ -142,43 +90,51 @@ if sys.version_info >= (3, 13):
 
     def start_joinable_thread(
         function: Callable[[], object], handle: _ThreadHandle | None = None, daemon: bool = True
-    ) -> _ThreadHandle: ...
+    ) -> _ThreadHandle:
+        """
+        *For internal use only*: start a new thread.
+
+        Like start_new_thread(), this starts a new thread calling the given function.
+        Unlike start_new_thread(), this returns a handle object with methods to join
+        or detach the given thread.
+        This function is not for third-party code, please use the
+        `threading` module instead. During finalization the runtime will not wait for
+        the thread to exit if daemon is True. If handle is provided it must be a
+        newly created thread._ThreadHandle instance.
+        """
+        ...
     lock = LockType
 
 @overload
 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.
+    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:
     """
-    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.
+    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.
     """
     ...
 
 if sys.version_info >= (3, 10):
     def interrupt_main(signum: signal.Signals = ..., /) -> None:
         """
-        interrupt_main(signum=signal.SIGINT, /)
-
         Simulate the arrival of the given signal in the main thread,
         where the corresponding signal handler will be executed.
         If *signum* is omitted, SIGINT is assumed.
@@ -200,26 +156,18 @@ else:
 
 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.
@@ -231,8 +179,6 @@ def get_ident() -> int:
     ...
 def stack_size(size: int = 0, /) -> 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
@@ -256,8 +202,6 @@ TIMEOUT_MAX: float
 
 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.
@@ -295,8 +239,6 @@ _excepthook: Callable[[_ExceptHookArgs], Any]
 if sys.version_info >= (3, 12):
     def daemon_threads_allowed() -> bool:
         """
-        daemon_threads_allowed()
-
         Return True if daemon threads are allowed in the current interpreter,
         and False otherwise.
         """

package/dist/typeshed-fallback/stdlib/asyncio/futures.pyi

@@ -44,7 +44,9 @@ class Future(Awaitable[_T], Iterable[_T]):
     def _log_traceback(self, val: Literal[False]) -> None: ...
     _asyncio_future_blocking: bool  # is a part of duck-typing contract for `Future`
     def __init__(self, *, loop: AbstractEventLoop | None = ...) -> None: ...
-    def __del__(self) -> None: ...
+    def __del__(self) -> None:
+        """Called when the instance is about to be destroyed."""
+        ...
     def get_loop(self) -> AbstractEventLoop:
         """Return the event loop the Future is bound to."""
         ...