basedpyright 1.13.1 → 1.13.2

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

@@ -1,154 +1,160 @@
-import sys
-from _typeshed import ReadableBuffer, Unused
-from collections.abc import Iterable, Iterator, Sized
-from typing import NoReturn, overload
-from typing_extensions import Self
-
-ACCESS_DEFAULT: int
-ACCESS_READ: int
-ACCESS_WRITE: int
-ACCESS_COPY: int
-
-ALLOCATIONGRANULARITY: int
-
-if sys.platform == "linux":
-    MAP_DENYWRITE: int
-    MAP_EXECUTABLE: int
-    if sys.version_info >= (3, 10):
-        MAP_POPULATE: int
-if sys.version_info >= (3, 11) and sys.platform != "win32" and sys.platform != "darwin":
-    MAP_STACK: int
-
-if sys.platform != "win32":
-    MAP_ANON: int
-    MAP_ANONYMOUS: int
-    MAP_PRIVATE: int
-    MAP_SHARED: int
-    PROT_EXEC: int
-    PROT_READ: int
-    PROT_WRITE: int
-
-PAGESIZE: int
-
-class mmap(Iterable[int], Sized):
-    """
-    Windows: mmap(fileno, length[, tagname[, access[, offset]]])
-
-    Maps length bytes from the file specified by the file handle fileno,
-    and returns a mmap object.  If length is larger than the current size
-    of the file, the file is extended to contain length bytes.  If length
-    is 0, the maximum length of the map is the current size of the file,
-    except that if the file is empty Windows raises an exception (you cannot
-    create an empty mapping on Windows).
-
-    Unix: mmap(fileno, length[, flags[, prot[, access[, offset]]]])
-
-    Maps length bytes from the file specified by the file descriptor fileno,
-    and returns a mmap object.  If length is 0, the maximum length of the map
-    will be the current size of the file when mmap is called.
-    flags specifies the nature of the mapping. MAP_PRIVATE creates a
-    private copy-on-write mapping, so changes to the contents of the mmap
-    object will be private to this process, and MAP_SHARED creates a mapping
-    that's shared with all other processes mapping the same areas of the file.
-    The default value is MAP_SHARED.
-
-    To map anonymous memory, pass -1 as the fileno (both versions).
-    """
-    if sys.platform == "win32":
-        def __init__(self, fileno: int, length: int, tagname: str | None = ..., access: int = ..., offset: int = ...) -> None: ...
-    else:
-        def __init__(
-            self, fileno: int, length: int, flags: int = ..., prot: int = ..., access: int = ..., offset: int = ...
-        ) -> None: ...
-
-    def close(self) -> None: ...
-    def flush(self, offset: int = ..., size: int = ...) -> None: ...
-    def move(self, dest: int, src: int, count: int) -> None: ...
-    def read_byte(self) -> int: ...
-    def readline(self) -> bytes: ...
-    def resize(self, newsize: int) -> None: ...
-    def seek(self, pos: int, whence: int = ...) -> None: ...
-    def size(self) -> int: ...
-    def tell(self) -> int: ...
-    def write_byte(self, byte: int) -> None: ...
-    def __len__(self) -> int:
-        """Return len(self)."""
-        ...
-    closed: bool
-    if sys.platform != "win32":
-        def madvise(self, option: int, start: int = ..., length: int = ...) -> None: ...
-
-    def find(self, sub: ReadableBuffer, start: int = ..., stop: int = ...) -> int: ...
-    def rfind(self, sub: ReadableBuffer, start: int = ..., stop: int = ...) -> int: ...
-    def read(self, n: int | None = ...) -> bytes: ...
-    def write(self, bytes: ReadableBuffer) -> int: ...
-    @overload
-    def __getitem__(self, key: int, /) -> int:
-        """Return self[key]."""
-        ...
-    @overload
-    def __getitem__(self, key: slice, /) -> bytes:
-        """Return self[key]."""
-        ...
-    def __delitem__(self, key: int | slice, /) -> NoReturn:
-        """Delete self[key]."""
-        ...
-    @overload
-    def __setitem__(self, key: int, value: int, /) -> None:
-        """Set self[key] to value."""
-        ...
-    @overload
-    def __setitem__(self, key: slice, value: ReadableBuffer, /) -> None:
-        """Set self[key] to value."""
-        ...
-    # Doesn't actually exist, but the object actually supports "in" because it has __getitem__,
-    # so we claim that there is also a __contains__ to help type checkers.
-    def __contains__(self, o: object, /) -> bool: ...
-    # Doesn't actually exist, but the object is actually iterable because it has __getitem__ and __len__,
-    # so we claim that there is also an __iter__ to help type checkers.
-    def __iter__(self) -> Iterator[int]: ...
-    def __enter__(self) -> Self: ...
-    def __exit__(self, *args: Unused) -> None: ...
-    def __buffer__(self, flags: int, /) -> memoryview:
-        """Return a buffer object that exposes the underlying memory of the object."""
-        ...
-    def __release_buffer__(self, buffer: memoryview, /) -> None:
-        """Release the buffer object that exposes the underlying memory of the object."""
-        ...
-    if sys.version_info >= (3, 13):
-        def seekable(self) -> bool: ...
-
-if sys.platform != "win32":
-    MADV_NORMAL: int
-    MADV_RANDOM: int
-    MADV_SEQUENTIAL: int
-    MADV_WILLNEED: int
-    MADV_DONTNEED: int
-    MADV_FREE: int
-
-if sys.platform == "linux":
-    MADV_REMOVE: int
-    MADV_DONTFORK: int
-    MADV_DOFORK: int
-    MADV_HWPOISON: int
-    MADV_MERGEABLE: int
-    MADV_UNMERGEABLE: int
-    # Seems like this constant is not defined in glibc.
-    # See https://github.com/python/typeshed/pull/5360 for details
-    # MADV_SOFT_OFFLINE: int
-    MADV_HUGEPAGE: int
-    MADV_NOHUGEPAGE: int
-    MADV_DONTDUMP: int
-    MADV_DODUMP: int
-
-# This Values are defined for FreeBSD but type checkers do not support conditions for these
-if sys.platform != "linux" and sys.platform != "darwin" and sys.platform != "win32":
-    MADV_NOSYNC: int
-    MADV_AUTOSYNC: int
-    MADV_NOCORE: int
-    MADV_CORE: int
-    MADV_PROTECT: int
-
-if sys.version_info >= (3, 10) and sys.platform == "darwin":
-    MADV_FREE_REUSABLE: int
-    MADV_FREE_REUSE: int
+import sys
+from _typeshed import ReadableBuffer, Unused
+from collections.abc import Iterable, Iterator, Sized
+from typing import Final, NoReturn, overload
+from typing_extensions import Self
+
+ACCESS_DEFAULT: int
+ACCESS_READ: int
+ACCESS_WRITE: int
+ACCESS_COPY: int
+
+ALLOCATIONGRANULARITY: int
+
+if sys.platform == "linux":
+    MAP_DENYWRITE: int
+    MAP_EXECUTABLE: int
+    if sys.version_info >= (3, 10):
+        MAP_POPULATE: int
+if sys.version_info >= (3, 11) and sys.platform != "win32" and sys.platform != "darwin":
+    MAP_STACK: int
+
+if sys.platform != "win32":
+    MAP_ANON: int
+    MAP_ANONYMOUS: int
+    MAP_PRIVATE: int
+    MAP_SHARED: int
+    PROT_EXEC: int
+    PROT_READ: int
+    PROT_WRITE: int
+
+PAGESIZE: int
+
+class mmap(Iterable[int], Sized):
+    """
+    Windows: mmap(fileno, length[, tagname[, access[, offset]]])
+
+    Maps length bytes from the file specified by the file handle fileno,
+    and returns a mmap object.  If length is larger than the current size
+    of the file, the file is extended to contain length bytes.  If length
+    is 0, the maximum length of the map is the current size of the file,
+    except that if the file is empty Windows raises an exception (you cannot
+    create an empty mapping on Windows).
+
+    Unix: mmap(fileno, length[, flags[, prot[, access[, offset]]]])
+
+    Maps length bytes from the file specified by the file descriptor fileno,
+    and returns a mmap object.  If length is 0, the maximum length of the map
+    will be the current size of the file when mmap is called.
+    flags specifies the nature of the mapping. MAP_PRIVATE creates a
+    private copy-on-write mapping, so changes to the contents of the mmap
+    object will be private to this process, and MAP_SHARED creates a mapping
+    that's shared with all other processes mapping the same areas of the file.
+    The default value is MAP_SHARED.
+
+    To map anonymous memory, pass -1 as the fileno (both versions).
+    """
+    if sys.platform == "win32":
+        def __init__(self, fileno: int, length: int, tagname: str | None = ..., access: int = ..., offset: int = ...) -> None: ...
+    else:
+        def __init__(
+            self, fileno: int, length: int, flags: int = ..., prot: int = ..., access: int = ..., offset: int = ...
+        ) -> None: ...
+
+    def close(self) -> None: ...
+    def flush(self, offset: int = ..., size: int = ...) -> None: ...
+    def move(self, dest: int, src: int, count: int) -> None: ...
+    def read_byte(self) -> int: ...
+    def readline(self) -> bytes: ...
+    def resize(self, newsize: int) -> None: ...
+    def seek(self, pos: int, whence: int = ...) -> None: ...
+    def size(self) -> int: ...
+    def tell(self) -> int: ...
+    def write_byte(self, byte: int) -> None: ...
+    def __len__(self) -> int:
+        """Return len(self)."""
+        ...
+    closed: bool
+    if sys.platform != "win32":
+        def madvise(self, option: int, start: int = ..., length: int = ...) -> None: ...
+
+    def find(self, sub: ReadableBuffer, start: int = ..., stop: int = ...) -> int: ...
+    def rfind(self, sub: ReadableBuffer, start: int = ..., stop: int = ...) -> int: ...
+    def read(self, n: int | None = ...) -> bytes: ...
+    def write(self, bytes: ReadableBuffer) -> int: ...
+    @overload
+    def __getitem__(self, key: int, /) -> int:
+        """Return self[key]."""
+        ...
+    @overload
+    def __getitem__(self, key: slice, /) -> bytes:
+        """Return self[key]."""
+        ...
+    def __delitem__(self, key: int | slice, /) -> NoReturn:
+        """Delete self[key]."""
+        ...
+    @overload
+    def __setitem__(self, key: int, value: int, /) -> None:
+        """Set self[key] to value."""
+        ...
+    @overload
+    def __setitem__(self, key: slice, value: ReadableBuffer, /) -> None:
+        """Set self[key] to value."""
+        ...
+    # Doesn't actually exist, but the object actually supports "in" because it has __getitem__,
+    # so we claim that there is also a __contains__ to help type checkers.
+    def __contains__(self, o: object, /) -> bool: ...
+    # Doesn't actually exist, but the object is actually iterable because it has __getitem__ and __len__,
+    # so we claim that there is also an __iter__ to help type checkers.
+    def __iter__(self) -> Iterator[int]: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(self, *args: Unused) -> None: ...
+    def __buffer__(self, flags: int, /) -> memoryview:
+        """Return a buffer object that exposes the underlying memory of the object."""
+        ...
+    def __release_buffer__(self, buffer: memoryview, /) -> None:
+        """Release the buffer object that exposes the underlying memory of the object."""
+        ...
+    if sys.version_info >= (3, 13):
+        def seekable(self) -> bool: ...
+
+if sys.platform != "win32":
+    MADV_NORMAL: int
+    MADV_RANDOM: int
+    MADV_SEQUENTIAL: int
+    MADV_WILLNEED: int
+    MADV_DONTNEED: int
+    MADV_FREE: int
+
+if sys.platform == "linux":
+    MADV_REMOVE: int
+    MADV_DONTFORK: int
+    MADV_DOFORK: int
+    MADV_HWPOISON: int
+    MADV_MERGEABLE: int
+    MADV_UNMERGEABLE: int
+    # Seems like this constant is not defined in glibc.
+    # See https://github.com/python/typeshed/pull/5360 for details
+    # MADV_SOFT_OFFLINE: int
+    MADV_HUGEPAGE: int
+    MADV_NOHUGEPAGE: int
+    MADV_DONTDUMP: int
+    MADV_DODUMP: int
+
+# This Values are defined for FreeBSD but type checkers do not support conditions for these
+if sys.platform != "linux" and sys.platform != "darwin" and sys.platform != "win32":
+    MADV_NOSYNC: int
+    MADV_AUTOSYNC: int
+    MADV_NOCORE: int
+    MADV_CORE: int
+    MADV_PROTECT: int
+
+if sys.version_info >= (3, 10) and sys.platform == "darwin":
+    MADV_FREE_REUSABLE: int
+    MADV_FREE_REUSE: int
+
+if sys.version_info >= (3, 13) and sys.platform != "win32":
+    MAP_32BIT: Final = 32768
+
+if sys.version_info >= (3, 13) and sys.platform == "darwin":
+    MAP_TPRO: Final = 524288

package/dist/typeshed-fallback/stdlib/multiprocessing/context.pyi

@@ -93,16 +93,20 @@ class BaseContext:
     def Value(self, typecode_or_type: str | type[_CData], *args: Any, lock: bool | _LockLike = True) -> Any: ...
     @overload
     def Array(
-        self, typecode_or_type: type[c_char], size_or_initializer: int | Sequence[Any], *, lock: Literal[True] | _LockLike = True
-    ) -> SynchronizedString: ...
+        self, typecode_or_type: type[_SimpleCData[_T]], size_or_initializer: int | Sequence[Any], *, lock: Literal[False]
+    ) -> SynchronizedArray[_T]: ...
     @overload
     def Array(
-        self, typecode_or_type: type[_CT], size_or_initializer: int | Sequence[Any], *, lock: Literal[False]
-    ) -> SynchronizedArray[_CT]: ...
+        self, typecode_or_type: type[c_char], size_or_initializer: int | Sequence[Any], *, lock: Literal[True] | _LockLike = True
+    ) -> SynchronizedString: ...
     @overload
     def Array(
-        self, typecode_or_type: type[_CT], size_or_initializer: int | Sequence[Any], *, lock: Literal[True] | _LockLike = True
-    ) -> SynchronizedArray[_CT]: ...
+        self,
+        typecode_or_type: type[_SimpleCData[_T]],
+        size_or_initializer: int | Sequence[Any],
+        *,
+        lock: Literal[True] | _LockLike = True,
+    ) -> SynchronizedArray[_T]: ...
     @overload
     def Array(
         self, typecode_or_type: str, size_or_initializer: int | Sequence[Any], *, lock: Literal[True] | _LockLike = True

package/dist/typeshed-fallback/stdlib/multiprocessing/sharedctypes.pyi

@@ -39,12 +39,20 @@ def Array(
 ) -> _CT: ...
 @overload
 def Array(
-    typecode_or_type: type[_CT],
+    typecode_or_type: type[c_char],
     size_or_initializer: int | Sequence[Any],
     *,
     lock: Literal[True] | _LockLike = True,
     ctx: BaseContext | None = None,
-) -> SynchronizedArray[_CT]: ...
+) -> SynchronizedString: ...
+@overload
+def Array(
+    typecode_or_type: type[_SimpleCData[_T]],
+    size_or_initializer: int | Sequence[Any],
+    *,
+    lock: Literal[True] | _LockLike = True,
+    ctx: BaseContext | None = None,
+) -> SynchronizedArray[_T]: ...
 @overload
 def Array(
     typecode_or_type: str,
@@ -65,9 +73,11 @@ def copy(obj: _CT) -> _CT: ...
 @overload
 def synchronized(obj: _SimpleCData[_T], lock: _LockLike | None = None, ctx: Any | None = None) -> Synchronized[_T]: ...
 @overload
-def synchronized(obj: ctypes.Array[c_char], lock: _LockLike | None = None, ctx: Any | None = None) -> SynchronizedString: ...
+def synchronized(obj: ctypes.Array[c_char], lock: _LockLike | None = None, ctx: Any | None = None) -> SynchronizedString: ...  # type: ignore
 @overload
-def synchronized(obj: ctypes.Array[_CT], lock: _LockLike | None = None, ctx: Any | None = None) -> SynchronizedArray[_CT]: ...
+def synchronized(
+    obj: ctypes.Array[_SimpleCData[_T]], lock: _LockLike | None = None, ctx: Any | None = None
+) -> SynchronizedArray[_T]: ...
 @overload
 def synchronized(obj: _CT, lock: _LockLike | None = None, ctx: Any | None = None) -> SynchronizedBase[_CT]: ...
 
@@ -89,19 +99,30 @@ class SynchronizedBase(Generic[_CT]):
 class Synchronized(SynchronizedBase[_SimpleCData[_T]], Generic[_T]):
     value: _T
 
-class SynchronizedArray(SynchronizedBase[ctypes.Array[_CT]], Generic[_CT]):
+class SynchronizedArray(SynchronizedBase[ctypes.Array[_SimpleCData[_T]]], Generic[_T]):
     def __len__(self) -> int: ...
     @overload
-    def __getitem__(self, i: slice) -> list[_CT]: ...
+    def __getitem__(self, i: slice) -> list[_T]: ...
     @overload
-    def __getitem__(self, i: int) -> _CT: ...
+    def __getitem__(self, i: int) -> _T: ...
     @overload
-    def __setitem__(self, i: slice, value: Iterable[_CT]) -> None: ...
+    def __setitem__(self, i: slice, value: Iterable[_T]) -> None: ...
     @overload
-    def __setitem__(self, i: int, value: _CT) -> None: ...
-    def __getslice__(self, start: int, stop: int) -> list[_CT]: ...
-    def __setslice__(self, start: int, stop: int, values: Iterable[_CT]) -> None: ...
+    def __setitem__(self, i: int, value: _T) -> None: ...
+    def __getslice__(self, start: int, stop: int) -> list[_T]: ...
+    def __setslice__(self, start: int, stop: int, values: Iterable[_T]) -> None: ...
+
+class SynchronizedString(SynchronizedArray[bytes]):
+    @overload  # type: ignore[override]
+    def __getitem__(self, i: slice) -> bytes: ...
+    @overload  # type: ignore[override]
+    def __getitem__(self, i: int) -> bytes: ...
+    @overload  # type: ignore[override]
+    def __setitem__(self, i: slice, value: bytes) -> None: ...
+    @overload  # type: ignore[override]
+    def __setitem__(self, i: int, value: bytes) -> None: ...  # type: ignore[override]
+    def __getslice__(self, start: int, stop: int) -> bytes: ...  # type: ignore[override]
+    def __setslice__(self, start: int, stop: int, values: bytes) -> None: ...  # type: ignore[override]
 
-class SynchronizedString(SynchronizedArray[c_char]):
     value: bytes
     raw: bytes

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

@@ -914,8 +914,8 @@ if sys.platform != "win32":
     def forkpty() -> tuple[int, int]: ...  # some flavors of Unix
     def killpg(pgid: int, signal: int, /) -> None: ...
     def nice(increment: int, /) -> int: ...
-    if sys.platform != "darwin":
-        def plock(op: int, /) -> None: ...  # ???op is int?
+    if sys.platform != "darwin" and sys.platform != "linux":
+        def plock(op: int, /) -> None: ...
 
 class _wrap_close(_TextIOWrapper):
     def __init__(self, stream: _TextIOWrapper, proc: Popen[str]) -> None: ...
@@ -1141,16 +1141,16 @@ if sys.version_info >= (3, 10) and sys.platform == "linux":
 if sys.version_info >= (3, 12) and sys.platform == "linux":
     CLONE_FILES: int
     CLONE_FS: int
-    CLONE_NEWCGROUP: int
-    CLONE_NEWIPC: int
-    CLONE_NEWNET: int
+    CLONE_NEWCGROUP: int  # Linux 4.6+
+    CLONE_NEWIPC: int  # Linux 2.6.19+
+    CLONE_NEWNET: int  # Linux 2.6.24+
     CLONE_NEWNS: int
-    CLONE_NEWPID: int
-    CLONE_NEWTIME: int
-    CLONE_NEWUSER: int
-    CLONE_NEWUTS: int
+    CLONE_NEWPID: int  # Linux 3.8+
+    CLONE_NEWTIME: int  # Linux 5.6+
+    CLONE_NEWUSER: int  # Linux 3.8+
+    CLONE_NEWUTS: int  # Linux 2.6.19+
     CLONE_SIGHAND: int
-    CLONE_SYSVSEM: int
+    CLONE_SYSVSEM: int  # Linux 2.6.26+
     CLONE_THREAD: int
     CLONE_VM: int
     def unshare(flags: int) -> None: ...

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

@@ -77,11 +77,7 @@ pathsep: LiteralString
 defpath: LiteralString
 devnull: LiteralString
 
-# Overloads are necessary to work around python/mypy#3644.
-@overload
-def abspath(path: PathLike[AnyStr]) -> AnyStr: ...
-@overload
-def abspath(path: AnyStr) -> AnyStr: ...
+def abspath(path: PathLike[AnyStr] | AnyStr) -> AnyStr: ...
 @overload
 def basename(p: PathLike[AnyStr]) -> AnyStr: ...
 @overload
@@ -90,14 +86,8 @@ def basename(p: AnyOrLiteralStr) -> AnyOrLiteralStr: ...
 def dirname(p: PathLike[AnyStr]) -> AnyStr: ...
 @overload
 def dirname(p: AnyOrLiteralStr) -> AnyOrLiteralStr: ...
-@overload
-def expanduser(path: PathLike[AnyStr]) -> AnyStr: ...
-@overload
-def expanduser(path: AnyStr) -> AnyStr: ...
-@overload
-def expandvars(path: PathLike[AnyStr]) -> AnyStr: ...
-@overload
-def expandvars(path: AnyStr) -> AnyStr: ...
+def expanduser(path: PathLike[AnyStr] | AnyStr) -> AnyStr: ...
+def expandvars(path: PathLike[AnyStr] | AnyStr) -> AnyStr: ...
 @overload
 def normcase(s: PathLike[AnyStr]) -> AnyStr: ...
 @overload

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

@@ -73,6 +73,15 @@ if sys.platform != "win32":
         def sp_flag(self) -> int:
             """reserved"""
             ...
+        # Deprecated aliases below.
+        @property
+        def sp_nam(self) -> str:
+            """login name; deprecated"""
+            ...
+        @property
+        def sp_pwd(self) -> str:
+            """encrypted password; deprecated"""
+            ...
 
     def getspall() -> list[struct_spwd]:
         """

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

@@ -889,6 +889,7 @@ if sys.version_info >= (3, 11):
         start_new_session: bool = False,
         pass_fds: Collection[int] = ...,
         *,
+        encoding: str | None = None,
         timeout: float | None = None,
         text: bool | None = None,
         user: str | int | None = None,
@@ -920,6 +921,7 @@ elif sys.version_info >= (3, 10):
         start_new_session: bool = False,
         pass_fds: Collection[int] = ...,
         *,
+        encoding: str | None = None,
         timeout: float | None = None,
         text: bool | None = None,
         user: str | int | None = None,
@@ -950,6 +952,7 @@ elif sys.version_info >= (3, 9):
         start_new_session: bool = False,
         pass_fds: Collection[int] = ...,
         *,
+        encoding: str | None = None,
         timeout: float | None = None,
         text: bool | None = None,
         user: str | int | None = None,
@@ -978,6 +981,7 @@ else:
         start_new_session: bool = False,
         pass_fds: Collection[int] = ...,
         *,
+        encoding: str | None = None,
         timeout: float | None = None,
         text: bool | None = None,
     ) -> int: ...
@@ -1005,6 +1009,7 @@ if sys.version_info >= (3, 11):
         pass_fds: Collection[int] = ...,
         timeout: float | None = ...,
         *,
+        encoding: str | None = None,
         text: bool | None = None,
         user: str | int | None = None,
         group: str | int | None = None,
@@ -1036,6 +1041,7 @@ elif sys.version_info >= (3, 10):
         pass_fds: Collection[int] = ...,
         timeout: float | None = ...,
         *,
+        encoding: str | None = None,
         text: bool | None = None,
         user: str | int | None = None,
         group: str | int | None = None,
@@ -1066,6 +1072,7 @@ elif sys.version_info >= (3, 9):
         pass_fds: Collection[int] = ...,
         timeout: float | None = ...,
         *,
+        encoding: str | None = None,
         text: bool | None = None,
         user: str | int | None = None,
         group: str | int | None = None,
@@ -1094,6 +1101,7 @@ else:
         pass_fds: Collection[int] = ...,
         timeout: float | None = ...,
         *,
+        encoding: str | None = None,
         text: bool | None = None,
     ) -> int: ...
 

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

@@ -103,10 +103,13 @@ PAX_NAME_FIELDS: set[str]
 
 ENCODING: str
 
+_FileCreationModes: TypeAlias = Literal["a", "w", "x"]
+
+@overload
 def open(
     name: StrOrBytesPath | None = None,
     mode: str = "r",
-    fileobj: IO[bytes] | None = None,  # depends on mode
+    fileobj: IO[bytes] | None = None,
     bufsize: int = 10240,
     *,
     format: int | None = ...,
@@ -121,6 +124,25 @@ def open(
     compresslevel: int | None = ...,
     preset: Literal[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] | None = ...,
 ) -> TarFile: ...
+@overload
+def open(
+    name: StrOrBytesPath | None = None,
+    mode: _FileCreationModes = ...,
+    fileobj: _Fileobj | None = None,
+    bufsize: int = 10240,
+    *,
+    format: int | None = ...,
+    tarinfo: type[TarInfo] | None = ...,
+    dereference: bool | None = ...,
+    ignore_zeros: bool | None = ...,
+    encoding: str | None = ...,
+    errors: str = ...,
+    pax_headers: Mapping[str, str] | None = ...,
+    debug: int | None = ...,
+    errorlevel: int | None = ...,
+    compresslevel: int | None = ...,
+    preset: int | None = ...,
+) -> TarFile: ...
 
 class ExFileObject(io.BufferedReader):
     def __init__(self, tarfile: TarFile, tarinfo: TarInfo) -> None: ...

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

@@ -88,6 +88,7 @@ NOOPT: bytes
 
 class Telnet:
     host: str | None  # undocumented
+    sock: socket.socket | None  # undocumented
     def __init__(self, host: str | None = None, port: int = 0, timeout: float = ...) -> None: ...
     def open(self, host: str, port: int = 0, timeout: float = ...) -> None: ...
     def msg(self, msg: str, *args: Any) -> None: ...

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

@@ -21,7 +21,7 @@ from types import (
     TracebackType,
     WrapperDescriptorType,
 )
-from typing_extensions import Never as _Never, ParamSpec as _ParamSpec
+from typing_extensions import Never as _Never, ParamSpec as _ParamSpec, deprecated
 
 if sys.version_info >= (3, 9):
     from types import GenericAlias
@@ -991,11 +991,30 @@ class ForwardRef:
         def __init__(self, arg: str, is_argument: bool = True) -> None: ...
 
     if sys.version_info >= (3, 13):
+        @overload
+        @deprecated(
+            "Failing to pass a value to the 'type_params' parameter of ForwardRef._evaluate() is deprecated, "
+            "as it leads to incorrect behaviour when evaluating a stringified annotation "
+            "that references a PEP 695 type parameter. It will be disallowed in Python 3.15."
+        )
+        def _evaluate(
+            self, globalns: dict[str, Any] | None, localns: dict[str, Any] | None, *, recursive_guard: frozenset[str]
+        ) -> Any | None: ...
+        @overload
+        def _evaluate(
+            self,
+            globalns: dict[str, Any] | None,
+            localns: dict[str, Any] | None,
+            type_params: tuple[TypeVar | ParamSpec | TypeVarTuple, ...],
+            *,
+            recursive_guard: frozenset[str],
+        ) -> Any | None: ...
+    elif sys.version_info >= (3, 12):
         def _evaluate(
             self,
             globalns: dict[str, Any] | None,
             localns: dict[str, Any] | None,
-            type_params: tuple[TypeVar | ParamSpec | TypeVarTuple, ...] = ...,
+            type_params: tuple[TypeVar | ParamSpec | TypeVarTuple, ...] | None = None,
             *,
             recursive_guard: frozenset[str],
         ) -> Any | None: ...