basedpyright 1.25.0 → 1.26.0

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

@@ -1,7 +1,21 @@
+from _pickle import (
+    PickleError as PickleError,
+    Pickler as Pickler,
+    PicklingError as PicklingError,
+    Unpickler as Unpickler,
+    UnpicklingError as UnpicklingError,
+    _BufferCallback,
+    _ReadableFileobj,
+    _ReducedType,
+    dump as dump,
+    dumps as dumps,
+    load as load,
+    loads as loads,
+)
 from _typeshed import ReadableBuffer, SupportsWrite
-from collections.abc import Callable, Iterable, Iterator, Mapping
-from typing import Any, ClassVar, Protocol, SupportsBytes, SupportsIndex, final
-from typing_extensions import TypeAlias
+from collections.abc import Callable, Iterable, Mapping
+from typing import Any, ClassVar, SupportsBytes, SupportsIndex, final
+from typing_extensions import Self
 
 __all__ = [
     "PickleBuffer",
@@ -93,13 +107,9 @@ DEFAULT_PROTOCOL: int
 
 bytes_types: tuple[type[Any], ...]  # undocumented
 
-class _ReadableFileobj(Protocol):
-    def read(self, n: int, /) -> bytes: ...
-    def readline(self) -> bytes: ...
-
 @final
 class PickleBuffer:
-    def __init__(self, buffer: ReadableBuffer) -> None: ...
+    def __new__(cls, buffer: ReadableBuffer) -> Self: ...
     def raw(self) -> memoryview:
         """
         Return a memoryview of the raw memory underlying this buffer.
@@ -116,261 +126,6 @@ class PickleBuffer:
         """Release the buffer object that exposes the underlying memory of the object."""
         ...
 
-_BufferCallback: TypeAlias = Callable[[PickleBuffer], Any] | None
-
-def dump(
-    obj: Any,
-    file: SupportsWrite[bytes],
-    protocol: int | None = None,
-    *,
-    fix_imports: bool = True,
-    buffer_callback: _BufferCallback = None,
-) -> None:
-    """
-    Write a pickled representation of obj to the open file object file.
-
-    This is equivalent to ``Pickler(file, protocol).dump(obj)``, but may
-    be more efficient.
-
-    The optional *protocol* argument tells the pickler to use the given
-    protocol; supported protocols are 0, 1, 2, 3, 4 and 5.  The default
-    protocol is 4. It was introduced in Python 3.4, and is incompatible
-    with previous versions.
-
-    Specifying a negative protocol version selects the highest protocol
-    version supported.  The higher the protocol used, the more recent the
-    version of Python needed to read the pickle produced.
-
-    The *file* argument must have a write() method that accepts a single
-    bytes argument.  It can thus be a file object opened for binary
-    writing, an io.BytesIO instance, or any other custom object that meets
-    this interface.
-
-    If *fix_imports* is True and protocol is less than 3, pickle will try
-    to map the new Python 3 names to the old module names used in Python
-    2, so that the pickle data stream is readable with Python 2.
-
-    If *buffer_callback* is None (the default), buffer views are serialized
-    into *file* as part of the pickle stream.  It is an error if
-    *buffer_callback* is not None and *protocol* is None or smaller than 5.
-    """
-    ...
-def dumps(
-    obj: Any, protocol: int | None = None, *, fix_imports: bool = True, buffer_callback: _BufferCallback = None
-) -> bytes:
-    """
-    Return the pickled representation of the object as a bytes object.
-
-    The optional *protocol* argument tells the pickler to use the given
-    protocol; supported protocols are 0, 1, 2, 3, 4 and 5.  The default
-    protocol is 4. It was introduced in Python 3.4, and is incompatible
-    with previous versions.
-
-    Specifying a negative protocol version selects the highest protocol
-    version supported.  The higher the protocol used, the more recent the
-    version of Python needed to read the pickle produced.
-
-    If *fix_imports* is True and *protocol* is less than 3, pickle will
-    try to map the new Python 3 names to the old module names used in
-    Python 2, so that the pickle data stream is readable with Python 2.
-
-    If *buffer_callback* is None (the default), buffer views are serialized
-    into *file* as part of the pickle stream.  It is an error if
-    *buffer_callback* is not None and *protocol* is None or smaller than 5.
-    """
-    ...
-def load(
-    file: _ReadableFileobj,
-    *,
-    fix_imports: bool = True,
-    encoding: str = "ASCII",
-    errors: str = "strict",
-    buffers: Iterable[Any] | None = (),
-) -> Any:
-    """
-    Read and return an object from the pickle data stored in a file.
-
-    This is equivalent to ``Unpickler(file).load()``, but may be more
-    efficient.
-
-    The protocol version of the pickle is detected automatically, so no
-    protocol argument is needed.  Bytes past the pickled object's
-    representation are ignored.
-
-    The argument *file* must have two methods, a read() method that takes
-    an integer argument, and a readline() method that requires no
-    arguments.  Both methods should return bytes.  Thus *file* can be a
-    binary file object opened for reading, an io.BytesIO object, or any
-    other custom object that meets this interface.
-
-    Optional keyword arguments are *fix_imports*, *encoding* and *errors*,
-    which are used to control compatibility support for pickle stream
-    generated by Python 2.  If *fix_imports* is True, pickle will try to
-    map the old Python 2 names to the new names used in Python 3.  The
-    *encoding* and *errors* tell pickle how to decode 8-bit string
-    instances pickled by Python 2; these default to 'ASCII' and 'strict',
-    respectively.  The *encoding* can be 'bytes' to read these 8-bit
-    string instances as bytes objects.
-    """
-    ...
-def loads(
-    data: ReadableBuffer,
-    /,
-    *,
-    fix_imports: bool = True,
-    encoding: str = "ASCII",
-    errors: str = "strict",
-    buffers: Iterable[Any] | None = (),
-) -> Any:
-    """
-    Read and return an object from the given pickle data.
-
-    The protocol version of the pickle is detected automatically, so no
-    protocol argument is needed.  Bytes past the pickled object's
-    representation are ignored.
-
-    Optional keyword arguments are *fix_imports*, *encoding* and *errors*,
-    which are used to control compatibility support for pickle stream
-    generated by Python 2.  If *fix_imports* is True, pickle will try to
-    map the old Python 2 names to the new names used in Python 3.  The
-    *encoding* and *errors* tell pickle how to decode 8-bit string
-    instances pickled by Python 2; these default to 'ASCII' and 'strict',
-    respectively.  The *encoding* can be 'bytes' to read these 8-bit
-    string instances as bytes objects.
-    """
-    ...
-
-class PickleError(Exception): ...
-class PicklingError(PickleError): ...
-class UnpicklingError(PickleError): ...
-
-_ReducedType: TypeAlias = (
-    str
-    | tuple[Callable[..., Any], tuple[Any, ...]]
-    | tuple[Callable[..., Any], tuple[Any, ...], Any]
-    | tuple[Callable[..., Any], tuple[Any, ...], Any, Iterator[Any] | None]
-    | tuple[Callable[..., Any], tuple[Any, ...], Any, Iterator[Any] | None, Iterator[Any] | None]
-)
-
-class Pickler:
-    """
-    This takes a binary file for writing a pickle data stream.
-
-    The optional *protocol* argument tells the pickler to use the given
-    protocol; supported protocols are 0, 1, 2, 3, 4 and 5.  The default
-    protocol is 4. It was introduced in Python 3.4, and is incompatible
-    with previous versions.
-
-    Specifying a negative protocol version selects the highest protocol
-    version supported.  The higher the protocol used, the more recent the
-    version of Python needed to read the pickle produced.
-
-    The *file* argument must have a write() method that accepts a single
-    bytes argument. It can thus be a file object opened for binary
-    writing, an io.BytesIO instance, or any other custom object that meets
-    this interface.
-
-    If *fix_imports* is True and protocol is less than 3, pickle will try
-    to map the new Python 3 names to the old module names used in Python
-    2, so that the pickle data stream is readable with Python 2.
-
-    If *buffer_callback* is None (the default), buffer views are
-    serialized into *file* as part of the pickle stream.
-
-    If *buffer_callback* is not None, then it can be called any number
-    of times with a buffer view.  If the callback returns a false value
-    (such as None), the given buffer is out-of-band; otherwise the
-    buffer is serialized in-band, i.e. inside the pickle stream.
-
-    It is an error if *buffer_callback* is not None and *protocol*
-    is None or smaller than 5.
-    """
-    fast: bool
-    dispatch_table: Mapping[type, Callable[[Any], _ReducedType]]
-    bin: bool  # undocumented
-    dispatch: ClassVar[dict[type, Callable[[Unpickler, Any], None]]]  # undocumented, _Pickler only
-
-    def __init__(
-        self,
-        file: SupportsWrite[bytes],
-        protocol: int | None = None,
-        *,
-        fix_imports: bool = True,
-        buffer_callback: _BufferCallback = None,
-    ) -> None: ...
-    def reducer_override(self, obj: Any) -> Any: ...
-    def dump(self, obj: Any, /) -> None:
-        """Write a pickled representation of the given object to the open file."""
-        ...
-    def clear_memo(self) -> None:
-        """
-        Clears the pickler's "memo".
-
-        The memo is the data structure that remembers which objects the
-        pickler has already seen, so that shared or recursive objects are
-        pickled by reference and not by value.  This method is useful when
-        re-using picklers.
-        """
-        ...
-    def persistent_id(self, obj: Any) -> Any: ...
-
-class Unpickler:
-    """
-    This takes a binary file for reading a pickle data stream.
-
-    The protocol version of the pickle is detected automatically, so no
-    protocol argument is needed.  Bytes past the pickled object's
-    representation are ignored.
-
-    The argument *file* must have two methods, a read() method that takes
-    an integer argument, and a readline() method that requires no
-    arguments.  Both methods should return bytes.  Thus *file* can be a
-    binary file object opened for reading, an io.BytesIO object, or any
-    other custom object that meets this interface.
-
-    Optional keyword arguments are *fix_imports*, *encoding* and *errors*,
-    which are used to control compatibility support for pickle stream
-    generated by Python 2.  If *fix_imports* is True, pickle will try to
-    map the old Python 2 names to the new names used in Python 3.  The
-    *encoding* and *errors* tell pickle how to decode 8-bit string
-    instances pickled by Python 2; these default to 'ASCII' and 'strict',
-    respectively.  The *encoding* can be 'bytes' to read these 8-bit
-    string instances as bytes objects.
-    """
-    dispatch: ClassVar[dict[int, Callable[[Unpickler], None]]]  # undocumented, _Unpickler only
-
-    def __init__(
-        self,
-        file: _ReadableFileobj,
-        *,
-        fix_imports: bool = True,
-        encoding: str = "ASCII",
-        errors: str = "strict",
-        buffers: Iterable[Any] | None = (),
-    ) -> None: ...
-    def load(self) -> Any:
-        """
-        Load a pickle.
-
-        Read a pickled object representation from the open file object given
-        in the constructor, and return the reconstituted object hierarchy
-        specified therein.
-        """
-        ...
-    def find_class(self, module_name: str, global_name: str, /) -> Any:
-        """
-        Return an object from a specified module.
-
-        If necessary, the module will be imported. Subclasses may override
-        this method (e.g. to restrict unpickling of arbitrary classes and
-        functions).
-
-        This method is called whenever a class or a function object is
-        needed.  Both arguments passed are str objects.
-        """
-        ...
-    def persistent_load(self, pid: Any) -> Any: ...
-
 MARK: bytes
 STOP: bytes
 POP: bytes
@@ -454,6 +209,36 @@ READONLY_BUFFER: bytes
 def encode_long(x: int) -> bytes: ...  # undocumented
 def decode_long(data: Iterable[SupportsIndex] | SupportsBytes | ReadableBuffer) -> int: ...  # undocumented
 
-# pure-Python implementations
-_Pickler = Pickler  # undocumented
-_Unpickler = Unpickler  # undocumented
+# undocumented pure-Python implementations
+class _Pickler:
+    fast: bool
+    dispatch_table: Mapping[type, Callable[[Any], _ReducedType]]
+    bin: bool  # undocumented
+    dispatch: ClassVar[dict[type, Callable[[Unpickler, Any], None]]]  # undocumented, _Pickler only
+    reducer_override: Callable[[Any], Any]
+    def __init__(
+        self,
+        file: SupportsWrite[bytes],
+        protocol: int | None = None,
+        *,
+        fix_imports: bool = True,
+        buffer_callback: _BufferCallback = None,
+    ) -> None: ...
+    def dump(self, obj: Any) -> None: ...
+    def clear_memo(self) -> None: ...
+    def persistent_id(self, obj: Any) -> Any: ...
+
+class _Unpickler:
+    dispatch: ClassVar[dict[int, Callable[[Unpickler], None]]]  # undocumented, _Unpickler only
+    def __init__(
+        self,
+        file: _ReadableFileobj,
+        *,
+        fix_imports: bool = True,
+        encoding: str = "ASCII",
+        errors: str = "strict",
+        buffers: Iterable[Any] | None = None,
+    ) -> None: ...
+    def load(self) -> Any: ...
+    def find_class(self, module: str, name: str) -> Any: ...
+    def persistent_load(self, pid: Any) -> Any: ...

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

@@ -1,3 +1,4 @@
+import sys
 from collections.abc import Callable, Iterator, MutableMapping
 from typing import IO, Any
 from typing_extensions import TypeAlias
@@ -40,7 +41,13 @@ def read_uint8(f: IO[bytes]) -> int: ...
 
 uint8: ArgumentDescriptor
 
-def read_stringnl(f: IO[bytes], decode: bool = True, stripquotes: bool = True) -> bytes | str: ...
+if sys.version_info >= (3, 12):
+    def read_stringnl(
+        f: IO[bytes], decode: bool = True, stripquotes: bool = True, *, encoding: str = "latin-1"
+    ) -> bytes | str: ...
+
+else:
+    def read_stringnl(f: IO[bytes], decode: bool = True, stripquotes: bool = True) -> bytes | str: ...
 
 stringnl: ArgumentDescriptor
 

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

@@ -3,7 +3,7 @@ from _typeshed import ReadableBuffer
 from collections.abc import Mapping, MutableMapping
 from datetime import datetime
 from enum import Enum
-from typing import IO, Any
+from typing import IO, Any, ClassVar
 from typing_extensions import Self
 
 __all__ = ["InvalidFileException", "FMT_XML", "FMT_BINARY", "load", "dump", "loads", "dumps", "UID"]
@@ -100,6 +100,7 @@ if sys.version_info < (3, 9):
     class Data:
         data: bytes
         def __init__(self, data: bytes) -> None: ...
+        __hash__: ClassVar[None]  # type: ignore[assignment]
 
 class UID:
     data: int

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

@@ -1,6 +1,6 @@
 import sys
 from collections.abc import Callable
-from typing import Any, NamedTuple, type_check_only
+from typing import Any, ClassVar, NamedTuple, type_check_only
 from typing_extensions import TypeAlias
 
 __all__ = ["scheduler"]
@@ -25,7 +25,8 @@ else:
         argument: tuple[Any, ...]
         kwargs: dict[str, Any]
 
-    class Event(_EventBase): ...
+    class Event(_EventBase):
+        __hash__: ClassVar[None]  # type: ignore[assignment]
 
 class scheduler:
     timefunc: Callable[[], float]

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

@@ -9,7 +9,7 @@ import sys
 from _typeshed import FileDescriptorLike
 from collections.abc import Iterable
 from types import TracebackType
-from typing import Any, final
+from typing import Any, ClassVar, final
 from typing_extensions import Self
 
 if sys.platform != "win32":
@@ -17,7 +17,8 @@ if sys.platform != "win32":
     POLLERR: int
     POLLHUP: int
     POLLIN: int
-    POLLMSG: int
+    if sys.platform == "linux":
+        POLLMSG: int
     POLLNVAL: int
     POLLOUT: int
     POLLPRI: int
@@ -28,17 +29,20 @@ if sys.platform != "win32":
     POLLWRBAND: int
     POLLWRNORM: int
 
-class poll:
-    """
-    Returns a polling object.
+    # This is actually a function that returns an instance of a class.
+    # The class is not accessible directly, and also calls itself select.poll.
+    class poll:
+        """
+        Returns a polling object.
 
-    This object supports registering and unregistering file descriptors, and then
-    polling them for I/O events.
-    """
-    def register(self, fd: FileDescriptorLike, eventmask: int = ...) -> None: ...
-    def modify(self, fd: FileDescriptorLike, eventmask: int) -> None: ...
-    def unregister(self, fd: FileDescriptorLike) -> None: ...
-    def poll(self, timeout: float | None = ...) -> list[tuple[int, int]]: ...
+        This object supports registering and unregistering file descriptors, and then
+        polling them for I/O events.
+        """
+        # default value is select.POLLIN | select.POLLPRI | select.POLLOUT
+        def register(self, fd: FileDescriptorLike, eventmask: int = 7, /) -> None: ...
+        def modify(self, fd: FileDescriptorLike, eventmask: int, /) -> None: ...
+        def unregister(self, fd: FileDescriptorLike, /) -> None: ...
+        def poll(self, timeout: float | None = None, /) -> list[tuple[int, int]]: ...
 
 def select(
     rlist: Iterable[Any], wlist: Iterable[Any], xlist: Iterable[Any], timeout: float | None = None, /
@@ -106,6 +110,7 @@ if sys.platform != "linux" and sys.platform != "win32":
             data: Any = ...,
             udata: Any = ...,
         ) -> None: ...
+        __hash__: ClassVar[None]  # type: ignore[assignment]
 
     # BSD only
     @final
@@ -169,7 +174,8 @@ if sys.platform != "linux" and sys.platform != "win32":
     KQ_EV_ONESHOT: int
     KQ_EV_SYSFLAGS: int
     KQ_FILTER_AIO: int
-    KQ_FILTER_NETDEV: int
+    if sys.platform != "darwin":
+        KQ_FILTER_NETDEV: int
     KQ_FILTER_PROC: int
     KQ_FILTER_READ: int
     KQ_FILTER_SIGNAL: int

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

@@ -50,10 +50,12 @@ if sys.platform == "linux":
     class EpollSelector(_PollLikeSelector):
         def fileno(self) -> int: ...
 
-class DevpollSelector(_PollLikeSelector):
-    def fileno(self) -> int: ...
+if sys.platform != "linux" and sys.platform != "darwin" and sys.platform != "win32":
+    # Solaris only
+    class DevpollSelector(_PollLikeSelector):
+        def fileno(self) -> int: ...
 
-if sys.platform != "win32":
+if sys.platform != "win32" and sys.platform != "linux":
     class KqueueSelector(_BaseSelectorImpl):
         def fileno(self) -> int: ...
         def select(self, timeout: float | None = None) -> list[tuple[SelectorKey, _EventMask]]: ...

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

@@ -3,7 +3,7 @@ from _typeshed import structseq
 from collections.abc import Callable, Iterable
 from enum import IntEnum
 from types import FrameType
-from typing import Any, Final, final
+from typing import Any, Final, Literal, final
 from typing_extensions import Never, TypeAlias
 
 NSIG: int
@@ -61,8 +61,8 @@ class Handlers(IntEnum):
     SIG_DFL = 0
     SIG_IGN = 1
 
-SIG_DFL: Handlers
-SIG_IGN: Handlers
+SIG_DFL: Literal[Handlers.SIG_DFL]
+SIG_IGN: Literal[Handlers.SIG_IGN]
 
 _SIGNUM: TypeAlias = int | Signals
 _HANDLER: TypeAlias = Callable[[int, FrameType | None], Any] | int | Handlers | None
@@ -83,45 +83,45 @@ else:
     def getsignal(signalnum: _SIGNUM, /) -> _HANDLER: ...
     def signal(signalnum: _SIGNUM, handler: _HANDLER, /) -> _HANDLER: ...
 
-SIGABRT: Signals
-SIGFPE: Signals
-SIGILL: Signals
-SIGINT: Signals
-SIGSEGV: Signals
-SIGTERM: Signals
+SIGABRT: Literal[Signals.SIGABRT]
+SIGFPE: Literal[Signals.SIGFPE]
+SIGILL: Literal[Signals.SIGILL]
+SIGINT: Literal[Signals.SIGINT]
+SIGSEGV: Literal[Signals.SIGSEGV]
+SIGTERM: Literal[Signals.SIGTERM]
 
 if sys.platform == "win32":
-    SIGBREAK: Signals
-    CTRL_C_EVENT: Signals
-    CTRL_BREAK_EVENT: Signals
+    SIGBREAK: Literal[Signals.SIGBREAK]
+    CTRL_C_EVENT: Literal[Signals.CTRL_C_EVENT]
+    CTRL_BREAK_EVENT: Literal[Signals.CTRL_BREAK_EVENT]
 else:
     if sys.platform != "linux":
-        SIGINFO: Signals
-        SIGEMT: Signals
-    SIGALRM: Signals
-    SIGBUS: Signals
-    SIGCHLD: Signals
-    SIGCONT: Signals
-    SIGHUP: Signals
-    SIGIO: Signals
-    SIGIOT: Signals
-    SIGKILL: Signals
-    SIGPIPE: Signals
-    SIGPROF: Signals
-    SIGQUIT: Signals
-    SIGSTOP: Signals
-    SIGSYS: Signals
-    SIGTRAP: Signals
-    SIGTSTP: Signals
-    SIGTTIN: Signals
-    SIGTTOU: Signals
-    SIGURG: Signals
-    SIGUSR1: Signals
-    SIGUSR2: Signals
-    SIGVTALRM: Signals
-    SIGWINCH: Signals
-    SIGXCPU: Signals
-    SIGXFSZ: Signals
+        SIGINFO: Literal[Signals.SIGINFO]
+        SIGEMT: Literal[Signals.SIGEMT]
+    SIGALRM: Literal[Signals.SIGALRM]
+    SIGBUS: Literal[Signals.SIGBUS]
+    SIGCHLD: Literal[Signals.SIGCHLD]
+    SIGCONT: Literal[Signals.SIGCONT]
+    SIGHUP: Literal[Signals.SIGHUP]
+    SIGIO: Literal[Signals.SIGIO]
+    SIGIOT: Literal[Signals.SIGABRT]  # alias
+    SIGKILL: Literal[Signals.SIGKILL]
+    SIGPIPE: Literal[Signals.SIGPIPE]
+    SIGPROF: Literal[Signals.SIGPROF]
+    SIGQUIT: Literal[Signals.SIGQUIT]
+    SIGSTOP: Literal[Signals.SIGSTOP]
+    SIGSYS: Literal[Signals.SIGSYS]
+    SIGTRAP: Literal[Signals.SIGTRAP]
+    SIGTSTP: Literal[Signals.SIGTSTP]
+    SIGTTIN: Literal[Signals.SIGTTIN]
+    SIGTTOU: Literal[Signals.SIGTTOU]
+    SIGURG: Literal[Signals.SIGURG]
+    SIGUSR1: Literal[Signals.SIGUSR1]
+    SIGUSR2: Literal[Signals.SIGUSR2]
+    SIGVTALRM: Literal[Signals.SIGVTALRM]
+    SIGWINCH: Literal[Signals.SIGWINCH]
+    SIGXCPU: Literal[Signals.SIGXCPU]
+    SIGXFSZ: Literal[Signals.SIGXFSZ]
 
     class ItimerError(OSError): ...
     ITIMER_PROF: int
@@ -133,9 +133,9 @@ else:
         SIG_UNBLOCK = 1
         SIG_SETMASK = 2
 
-    SIG_BLOCK = Sigmasks.SIG_BLOCK
-    SIG_UNBLOCK = Sigmasks.SIG_UNBLOCK
-    SIG_SETMASK = Sigmasks.SIG_SETMASK
+    SIG_BLOCK: Literal[Sigmasks.SIG_BLOCK]
+    SIG_UNBLOCK: Literal[Sigmasks.SIG_UNBLOCK]
+    SIG_SETMASK: Literal[Sigmasks.SIG_SETMASK]
     def alarm(seconds: int, /) -> int:
         """Arrange for SIGALRM to arrive after the given number of seconds."""
         ...
@@ -177,13 +177,13 @@ else:
     else:
         def sigwait(sigset: Iterable[int], /) -> _SIGNUM: ...
     if sys.platform != "darwin":
-        SIGCLD: Signals
-        SIGPOLL: Signals
-        SIGPWR: Signals
-        SIGRTMAX: Signals
-        SIGRTMIN: Signals
+        SIGCLD: Literal[Signals.SIGCHLD]  # alias
+        SIGPOLL: Literal[Signals.SIGIO]  # alias
+        SIGPWR: Literal[Signals.SIGPWR]
+        SIGRTMAX: Literal[Signals.SIGRTMAX]
+        SIGRTMIN: Literal[Signals.SIGRTMIN]
         if sys.version_info >= (3, 11):
-            SIGSTKFLT: Signals
+            SIGSTKFLT: Literal[Signals.SIGSTKFLT]
 
         @final
         class struct_siginfo(structseq[int], tuple[int, int, int, int, int, int, int]):

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

@@ -367,7 +367,6 @@ if sys.platform != "win32" and sys.platform != "darwin":
         IP_TRANSPARENT as IP_TRANSPARENT,
         IPX_TYPE as IPX_TYPE,
         SCM_CREDENTIALS as SCM_CREDENTIALS,
-        SO_BINDTODEVICE as SO_BINDTODEVICE,
         SO_DOMAIN as SO_DOMAIN,
         SO_MARK as SO_MARK,
         SO_PASSCRED as SO_PASSCRED,
@@ -396,7 +395,6 @@ if sys.platform != "win32" and sys.platform != "darwin":
     __all__ += [
         "IP_TRANSPARENT",
         "SCM_CREDENTIALS",
-        "SO_BINDTODEVICE",
         "SO_DOMAIN",
         "SO_MARK",
         "SO_PASSCRED",
@@ -517,6 +515,11 @@ if sys.platform != "win32":
             "IPV6_RTHDRDSTOPTS",
         ]
 
+    if sys.platform != "darwin" or sys.version_info >= (3, 13):
+        from _socket import SO_BINDTODEVICE as SO_BINDTODEVICE
+
+        __all__ += ["SO_BINDTODEVICE"]
+
 if sys.platform != "darwin" and sys.platform != "linux":
     if sys.platform != "win32" or sys.version_info >= (3, 9):
         from _socket import BDADDR_ANY as BDADDR_ANY, BDADDR_LOCAL as BDADDR_LOCAL, BTPROTO_RFCOMM as BTPROTO_RFCOMM
@@ -1046,7 +1049,6 @@ class AddressFamily(IntEnum):
     AF_INET = 2
     AF_INET6 = 10
     AF_APPLETALK = 5
-    AF_DECnet = ...
     AF_IPX = 4
     AF_SNA = 22
     AF_UNSPEC = 0
@@ -1096,7 +1098,7 @@ class AddressFamily(IntEnum):
 AF_INET = AddressFamily.AF_INET
 AF_INET6 = AddressFamily.AF_INET6
 AF_APPLETALK = AddressFamily.AF_APPLETALK
-AF_DECnet = AddressFamily.AF_DECnet
+AF_DECnet: Literal[12]
 AF_IPX = AddressFamily.AF_IPX
 AF_SNA = AddressFamily.AF_SNA
 AF_UNSPEC = AddressFamily.AF_UNSPEC
@@ -1407,7 +1409,7 @@ def create_server(
     address: _Address, *, family: int = ..., backlog: int | None = None, reuse_port: bool = False, dualstack_ipv6: bool = False
 ) -> socket: ...
 
-# the 5th tuple item is an address
+# The 5th tuple item is the socket address, for IP4, IP6, or IP6 if Python is compiled with --disable-ipv6, respectively.
 def getaddrinfo(
     host: bytes | str | None, port: bytes | str | int | None, family: int = 0, type: int = 0, proto: int = 0, flags: int = 0
-) -> list[tuple[AddressFamily, SocketKind, int, str, tuple[str, int] | tuple[str, int, int, int]]]: ...
+) -> list[tuple[AddressFamily, SocketKind, int, str, tuple[str, int] | tuple[str, int, int, int] | tuple[int, bytes]]]: ...

package/dist/typeshed-fallback/stdlib/sqlite3/__init__.pyi

@@ -683,7 +683,7 @@ class PrepareProtocol:
     def __init__(self, *args: object, **kwargs: object) -> None: ...
 
 class Row(Sequence[Any]):
-    def __init__(self, cursor: Cursor, data: tuple[Any, ...], /) -> None: ...
+    def __new__(cls, cursor: Cursor, data: tuple[Any, ...], /) -> Self: ...
     def keys(self) -> list[str]:
         """Returns the keys of the row."""
         ...