pyre-check-nightly 0.0.101729854749__py3-none-manylinux1_x86_64.whl → 0.0.101730373092__py3-none-manylinux1_x86_64.whl

pyre_check_nightly-0.0.101730373092.data/data/lib/pyre_check/typeshed/stdlib/io.pyi

@@ -0,0 +1,60 @@
+import abc
+import sys
+from _io import (
+    DEFAULT_BUFFER_SIZE as DEFAULT_BUFFER_SIZE,
+    BlockingIOError as BlockingIOError,
+    BufferedRandom as BufferedRandom,
+    BufferedReader as BufferedReader,
+    BufferedRWPair as BufferedRWPair,
+    BufferedWriter as BufferedWriter,
+    BytesIO as BytesIO,
+    FileIO as FileIO,
+    IncrementalNewlineDecoder as IncrementalNewlineDecoder,
+    StringIO as StringIO,
+    TextIOWrapper as TextIOWrapper,
+    _BufferedIOBase,
+    _IOBase,
+    _RawIOBase,
+    _TextIOBase,
+    _WrappedBuffer as _WrappedBuffer,  # used elsewhere in typeshed
+    open as open,
+    open_code as open_code,
+)
+from typing import Final
+
+__all__ = [
+    "BlockingIOError",
+    "open",
+    "open_code",
+    "IOBase",
+    "RawIOBase",
+    "FileIO",
+    "BytesIO",
+    "StringIO",
+    "BufferedIOBase",
+    "BufferedReader",
+    "BufferedWriter",
+    "BufferedRWPair",
+    "BufferedRandom",
+    "TextIOBase",
+    "TextIOWrapper",
+    "UnsupportedOperation",
+    "SEEK_SET",
+    "SEEK_CUR",
+    "SEEK_END",
+]
+
+if sys.version_info >= (3, 11):
+    from _io import text_encoding as text_encoding
+
+    __all__ += ["DEFAULT_BUFFER_SIZE", "IncrementalNewlineDecoder", "text_encoding"]
+
+SEEK_SET: Final = 0
+SEEK_CUR: Final = 1
+SEEK_END: Final = 2
+
+class UnsupportedOperation(OSError, ValueError): ...
+class IOBase(_IOBase, metaclass=abc.ABCMeta): ...
+class RawIOBase(_RawIOBase, IOBase): ...
+class BufferedIOBase(_BufferedIOBase, IOBase): ...
+class TextIOBase(_TextIOBase, IOBase): ...

{pyre_check_nightly-0.0.101729854749.data → pyre_check_nightly-0.0.101730373092.data}/data/lib/pyre_check/typeshed/stdlib/ipaddress.pyi

@@ -1,6 +1,6 @@
 import sys
 from collections.abc import Iterable, Iterator
-from typing import Any, Final, Generic, Literal, SupportsInt, TypeVar, overload
+from typing import Any, Final, Generic, Literal, TypeVar, overload
 from typing_extensions import Self, TypeAlias
 
 # Undocumented length constants
@@ -31,7 +31,7 @@ class _IPAddressBase:
     @property
     def version(self) -> int: ...
 
-class _BaseAddress(_IPAddressBase, SupportsInt):
+class _BaseAddress(_IPAddressBase):
     def __init__(self, address: object) -> None: ...
     def __add__(self, other: int) -> Self: ...
     def __hash__(self) -> int: ...

{pyre_check_nightly-0.0.101729854749.data → pyre_check_nightly-0.0.101730373092.data}/data/lib/pyre_check/typeshed/stdlib/itertools.pyi

@@ -1,4 +1,5 @@
 import sys
+from _typeshed import MaybeNone
 from collections.abc import Callable, Iterable, Iterator
 from typing import Any, Generic, Literal, SupportsComplex, SupportsFloat, SupportsIndex, SupportsInt, TypeVar, overload
 from typing_extensions import Self, TypeAlias
@@ -28,7 +29,7 @@ _Predicate: TypeAlias = Callable[[_T], object]
 
 # Technically count can take anything that implements a number protocol and has an add method
 # but we can't enforce the add method
-class count(Iterator[_N]):
+class count(Generic[_N]):
     @overload
     def __new__(cls) -> count[int]: ...
     @overload
@@ -38,12 +39,12 @@ class count(Iterator[_N]):
     def __next__(self) -> _N: ...
     def __iter__(self) -> Self: ...
 
-class cycle(Iterator[_T]):
+class cycle(Generic[_T]):
     def __init__(self, iterable: Iterable[_T], /) -> None: ...
     def __next__(self) -> _T: ...
     def __iter__(self) -> Self: ...
 
-class repeat(Iterator[_T]):
+class repeat(Generic[_T]):
     @overload
     def __init__(self, object: _T) -> None: ...
     @overload
@@ -52,7 +53,7 @@ class repeat(Iterator[_T]):
     def __iter__(self) -> Self: ...
     def __length_hint__(self) -> int: ...
 
-class accumulate(Iterator[_T]):
+class accumulate(Generic[_T]):
     @overload
     def __init__(self, iterable: Iterable[_T], func: None = None, *, initial: _T | None = ...) -> None: ...
     @overload
@@ -60,7 +61,7 @@ class accumulate(Iterator[_T]):
     def __iter__(self) -> Self: ...
     def __next__(self) -> _T: ...
 
-class chain(Iterator[_T]):
+class chain(Generic[_T]):
     def __init__(self, *iterables: Iterable[_T]) -> None: ...
     def __next__(self) -> _T: ...
     def __iter__(self) -> Self: ...
@@ -70,22 +71,22 @@ class chain(Iterator[_T]):
     if sys.version_info >= (3, 9):
         def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
-class compress(Iterator[_T]):
+class compress(Generic[_T]):
     def __init__(self, data: Iterable[_T], selectors: Iterable[Any]) -> None: ...
     def __iter__(self) -> Self: ...
     def __next__(self) -> _T: ...
 
-class dropwhile(Iterator[_T]):
+class dropwhile(Generic[_T]):
     def __init__(self, predicate: _Predicate[_T], iterable: Iterable[_T], /) -> None: ...
     def __iter__(self) -> Self: ...
     def __next__(self) -> _T: ...
 
-class filterfalse(Iterator[_T]):
+class filterfalse(Generic[_T]):
     def __init__(self, predicate: _Predicate[_T] | None, iterable: Iterable[_T], /) -> None: ...
     def __iter__(self) -> Self: ...
     def __next__(self) -> _T: ...
 
-class groupby(Iterator[tuple[_T_co, Iterator[_S_co]]], Generic[_T_co, _S_co]):
+class groupby(Generic[_T_co, _S_co]):
     @overload
     def __new__(cls, iterable: Iterable[_T1], key: None = None) -> groupby[_T1, _T1]: ...
     @overload
@@ -93,7 +94,7 @@ class groupby(Iterator[tuple[_T_co, Iterator[_S_co]]], Generic[_T_co, _S_co]):
     def __iter__(self) -> Self: ...
     def __next__(self) -> tuple[_T_co, Iterator[_S_co]]: ...
 
-class islice(Iterator[_T]):
+class islice(Generic[_T]):
     @overload
     def __init__(self, iterable: Iterable[_T], stop: int | None, /) -> None: ...
     @overload
@@ -101,19 +102,19 @@ class islice(Iterator[_T]):
     def __iter__(self) -> Self: ...
     def __next__(self) -> _T: ...
 
-class starmap(Iterator[_T_co]):
+class starmap(Generic[_T_co]):
     def __new__(cls, function: Callable[..., _T], iterable: Iterable[Iterable[Any]], /) -> starmap[_T]: ...
     def __iter__(self) -> Self: ...
     def __next__(self) -> _T_co: ...
 
-class takewhile(Iterator[_T]):
+class takewhile(Generic[_T]):
     def __init__(self, predicate: _Predicate[_T], iterable: Iterable[_T], /) -> None: ...
     def __iter__(self) -> Self: ...
     def __next__(self) -> _T: ...
 
 def tee(iterable: Iterable[_T], n: int = 2, /) -> tuple[Iterator[_T], ...]: ...
 
-class zip_longest(Iterator[_T_co]):
+class zip_longest(Generic[_T_co]):
     # one iterable (fillvalue doesn't matter)
     @overload
     def __new__(cls, iter1: Iterable[_T1], /, *, fillvalue: object = ...) -> zip_longest[tuple[_T1]]: ...
@@ -122,7 +123,7 @@ class zip_longest(Iterator[_T_co]):
     # In the overloads without fillvalue, all of the tuple members could theoretically be None,
     # but we return Any instead to avoid false positives for code where we know one of the iterables
     # is longer.
-    def __new__(cls, iter1: Iterable[_T1], iter2: Iterable[_T2], /) -> zip_longest[tuple[_T1 | Any, _T2 | Any]]: ...
+    def __new__(cls, iter1: Iterable[_T1], iter2: Iterable[_T2], /) -> zip_longest[tuple[_T1 | MaybeNone, _T2 | MaybeNone]]: ...
     @overload
     def __new__(
         cls, iter1: Iterable[_T1], iter2: Iterable[_T2], /, *, fillvalue: _T
@@ -131,7 +132,7 @@ class zip_longest(Iterator[_T_co]):
     @overload
     def __new__(
         cls, iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], /
-    ) -> zip_longest[tuple[_T1 | Any, _T2 | Any, _T3 | Any]]: ...
+    ) -> zip_longest[tuple[_T1 | MaybeNone, _T2 | MaybeNone, _T3 | MaybeNone]]: ...
     @overload
     def __new__(
         cls, iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], /, *, fillvalue: _T
@@ -140,7 +141,7 @@ class zip_longest(Iterator[_T_co]):
     @overload
     def __new__(
         cls, iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], iter4: Iterable[_T4], /
-    ) -> zip_longest[tuple[_T1 | Any, _T2 | Any, _T3 | Any, _T4 | Any]]: ...
+    ) -> zip_longest[tuple[_T1 | MaybeNone, _T2 | MaybeNone, _T3 | MaybeNone, _T4 | MaybeNone]]: ...
     @overload
     def __new__(
         cls, iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], iter4: Iterable[_T4], /, *, fillvalue: _T
@@ -149,7 +150,7 @@ class zip_longest(Iterator[_T_co]):
     @overload
     def __new__(
         cls, iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], iter4: Iterable[_T4], iter5: Iterable[_T5], /
-    ) -> zip_longest[tuple[_T1 | Any, _T2 | Any, _T3 | Any, _T4 | Any, _T5 | Any]]: ...
+    ) -> zip_longest[tuple[_T1 | MaybeNone, _T2 | MaybeNone, _T3 | MaybeNone, _T4 | MaybeNone, _T5 | MaybeNone]]: ...
     @overload
     def __new__(
         cls,
@@ -174,7 +175,7 @@ class zip_longest(Iterator[_T_co]):
         iter6: Iterable[_T],
         /,
         *iterables: Iterable[_T],
-    ) -> zip_longest[tuple[_T | Any, ...]]: ...
+    ) -> zip_longest[tuple[_T | MaybeNone, ...]]: ...
     @overload
     def __new__(
         cls,
@@ -191,7 +192,7 @@ class zip_longest(Iterator[_T_co]):
     def __iter__(self) -> Self: ...
     def __next__(self) -> _T_co: ...
 
-class product(Iterator[_T_co]):
+class product(Generic[_T_co]):
     @overload
     def __new__(cls, iter1: Iterable[_T1], /) -> product[tuple[_T1]]: ...
     @overload
@@ -276,7 +277,7 @@ class product(Iterator[_T_co]):
     def __iter__(self) -> Self: ...
     def __next__(self) -> _T_co: ...
 
-class permutations(Iterator[_T_co]):
+class permutations(Generic[_T_co]):
     @overload
     def __new__(cls, iterable: Iterable[_T], r: Literal[2]) -> permutations[tuple[_T, _T]]: ...
     @overload
@@ -290,7 +291,7 @@ class permutations(Iterator[_T_co]):
     def __iter__(self) -> Self: ...
     def __next__(self) -> _T_co: ...
 
-class combinations(Iterator[_T_co]):
+class combinations(Generic[_T_co]):
     @overload
     def __new__(cls, iterable: Iterable[_T], r: Literal[2]) -> combinations[tuple[_T, _T]]: ...
     @overload
@@ -304,7 +305,7 @@ class combinations(Iterator[_T_co]):
     def __iter__(self) -> Self: ...
     def __next__(self) -> _T_co: ...
 
-class combinations_with_replacement(Iterator[_T_co]):
+class combinations_with_replacement(Generic[_T_co]):
     @overload
     def __new__(cls, iterable: Iterable[_T], r: Literal[2]) -> combinations_with_replacement[tuple[_T, _T]]: ...
     @overload
@@ -319,13 +320,13 @@ class combinations_with_replacement(Iterator[_T_co]):
     def __next__(self) -> _T_co: ...
 
 if sys.version_info >= (3, 10):
-    class pairwise(Iterator[_T_co]):
+    class pairwise(Generic[_T_co]):
         def __new__(cls, iterable: Iterable[_T], /) -> pairwise[tuple[_T, _T]]: ...
         def __iter__(self) -> Self: ...
         def __next__(self) -> _T_co: ...
 
 if sys.version_info >= (3, 12):
-    class batched(Iterator[tuple[_T_co, ...]], Generic[_T_co]):
+    class batched(Generic[_T_co]):
         if sys.version_info >= (3, 13):
             def __new__(cls, iterable: Iterable[_T_co], n: int, *, strict: bool = False) -> Self: ...
         else:

{pyre_check_nightly-0.0.101729854749.data → pyre_check_nightly-0.0.101730373092.data}/data/lib/pyre_check/typeshed/stdlib/logging/config.pyi

@@ -116,7 +116,7 @@ class BaseConfigurator:  # undocumented
     def cfg_convert(self, value: str) -> Any: ...
     def convert(self, value: Any) -> Any: ...
     def configure_custom(self, config: dict[str, Any]) -> Any: ...
-    def as_tuple(self, value: list[Any] | tuple[Any]) -> tuple[Any]: ...
+    def as_tuple(self, value: list[Any] | tuple[Any, ...]) -> tuple[Any, ...]: ...
 
 class DictConfigurator(BaseConfigurator):
     def configure(self) -> None: ...  # undocumented

{pyre_check_nightly-0.0.101729854749.data → pyre_check_nightly-0.0.101730373092.data}/data/lib/pyre_check/typeshed/stdlib/mmap.pyi

@@ -1,6 +1,6 @@
 import sys
 from _typeshed import ReadableBuffer, Unused
-from collections.abc import Iterable, Iterator, Sized
+from collections.abc import Iterator
 from typing import Final, Literal, NoReturn, overload
 from typing_extensions import Self
 
@@ -30,7 +30,7 @@ if sys.platform != "win32":
 
 PAGESIZE: int
 
-class mmap(Iterable[int], Sized):
+class mmap:
     if sys.platform == "win32":
         def __init__(self, fileno: int, length: int, tagname: str | None = ..., access: int = ..., offset: int = ...) -> None: ...
     else:

{pyre_check_nightly-0.0.101729854749.data → pyre_check_nightly-0.0.101730373092.data}/data/lib/pyre_check/typeshed/stdlib/multiprocessing/pool.pyi

@@ -1,5 +1,5 @@
 import sys
-from collections.abc import Callable, Iterable, Iterator, Mapping
+from collections.abc import Callable, Iterable, Mapping
 from types import TracebackType
 from typing import Any, Final, Generic, TypeVar
 from typing_extensions import Self
@@ -36,7 +36,7 @@ class MapResult(ApplyResult[list[_T]]):
         error_callback: Callable[[BaseException], object] | None,
     ) -> None: ...
 
-class IMapIterator(Iterator[_T]):
+class IMapIterator(Generic[_T]):
     def __init__(self, pool: Pool) -> None: ...
     def __iter__(self) -> Self: ...
     def next(self, timeout: float | None = None) -> _T: ...

{pyre_check_nightly-0.0.101729854749.data → pyre_check_nightly-0.0.101730373092.data}/data/lib/pyre_check/typeshed/stdlib/multiprocessing/synchronize.pyi

@@ -1,6 +1,5 @@
 import threading
 from collections.abc import Callable
-from contextlib import AbstractContextManager
 from multiprocessing.context import BaseContext
 from types import TracebackType
 from typing_extensions import TypeAlias
@@ -14,7 +13,7 @@ class Barrier(threading.Barrier):
         self, parties: int, action: Callable[[], object] | None = None, timeout: float | None = None, *ctx: BaseContext
     ) -> None: ...
 
-class Condition(AbstractContextManager[bool, None]):
+class Condition:
     def __init__(self, lock: _LockLike | None = None, *, ctx: BaseContext) -> None: ...
     def notify(self, n: int = 1) -> None: ...
     def notify_all(self) -> None: ...
@@ -22,6 +21,7 @@ class Condition(AbstractContextManager[bool, None]):
     def wait_for(self, predicate: Callable[[], bool], timeout: float | None = None) -> bool: ...
     def acquire(self, block: bool = ..., timeout: float | None = ...) -> bool: ...
     def release(self) -> None: ...
+    def __enter__(self) -> bool: ...
     def __exit__(
         self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None, /
     ) -> None: ...
@@ -34,9 +34,10 @@ class Event:
     def wait(self, timeout: float | None = None) -> bool: ...
 
 # Not part of public API
-class SemLock(AbstractContextManager[bool, None]):
+class SemLock:
     def acquire(self, block: bool = ..., timeout: float | None = ...) -> bool: ...
     def release(self) -> None: ...
+    def __enter__(self) -> bool: ...
     def __exit__(
         self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None, /
     ) -> None: ...

pyre_check_nightly-0.0.101730373092.data/data/lib/pyre_check/typeshed/stdlib/operator.pyi

@@ -0,0 +1,215 @@
+import sys
+from _operator import (
+    abs as abs,
+    add as add,
+    and_ as and_,
+    concat as concat,
+    contains as contains,
+    countOf as countOf,
+    delitem as delitem,
+    eq as eq,
+    floordiv as floordiv,
+    ge as ge,
+    getitem as getitem,
+    gt as gt,
+    iadd as iadd,
+    iand as iand,
+    iconcat as iconcat,
+    ifloordiv as ifloordiv,
+    ilshift as ilshift,
+    imatmul as imatmul,
+    imod as imod,
+    imul as imul,
+    index as index,
+    indexOf as indexOf,
+    inv as inv,
+    invert as invert,
+    ior as ior,
+    ipow as ipow,
+    irshift as irshift,
+    is_ as is_,
+    is_not as is_not,
+    isub as isub,
+    itruediv as itruediv,
+    ixor as ixor,
+    le as le,
+    length_hint as length_hint,
+    lshift as lshift,
+    lt as lt,
+    matmul as matmul,
+    mod as mod,
+    mul as mul,
+    ne as ne,
+    neg as neg,
+    not_ as not_,
+    or_ as or_,
+    pos as pos,
+    pow as pow,
+    rshift as rshift,
+    setitem as setitem,
+    sub as sub,
+    truediv as truediv,
+    truth as truth,
+    xor as xor,
+)
+from _typeshed import SupportsGetItem
+from typing import Any, Generic, TypeVar, final, overload
+from typing_extensions import TypeVarTuple, Unpack
+
+_T = TypeVar("_T")
+_T_co = TypeVar("_T_co", covariant=True)
+_T1 = TypeVar("_T1")
+_T2 = TypeVar("_T2")
+_Ts = TypeVarTuple("_Ts")
+
+__all__ = [
+    "abs",
+    "add",
+    "and_",
+    "attrgetter",
+    "concat",
+    "contains",
+    "countOf",
+    "delitem",
+    "eq",
+    "floordiv",
+    "ge",
+    "getitem",
+    "gt",
+    "iadd",
+    "iand",
+    "iconcat",
+    "ifloordiv",
+    "ilshift",
+    "imatmul",
+    "imod",
+    "imul",
+    "index",
+    "indexOf",
+    "inv",
+    "invert",
+    "ior",
+    "ipow",
+    "irshift",
+    "is_",
+    "is_not",
+    "isub",
+    "itemgetter",
+    "itruediv",
+    "ixor",
+    "le",
+    "length_hint",
+    "lshift",
+    "lt",
+    "matmul",
+    "methodcaller",
+    "mod",
+    "mul",
+    "ne",
+    "neg",
+    "not_",
+    "or_",
+    "pos",
+    "pow",
+    "rshift",
+    "setitem",
+    "sub",
+    "truediv",
+    "truth",
+    "xor",
+]
+
+if sys.version_info >= (3, 11):
+    from _operator import call as call
+
+    __all__ += ["call"]
+
+if sys.version_info >= (3, 14):
+    from _operator import is_none as is_none, is_not_none as is_not_none
+
+    __all__ += ["is_none", "is_not_none"]
+
+__lt__ = lt
+__le__ = le
+__eq__ = eq
+__ne__ = ne
+__ge__ = ge
+__gt__ = gt
+__not__ = not_
+__abs__ = abs
+__add__ = add
+__and__ = and_
+__floordiv__ = floordiv
+__index__ = index
+__inv__ = inv
+__invert__ = invert
+__lshift__ = lshift
+__mod__ = mod
+__mul__ = mul
+__matmul__ = matmul
+__neg__ = neg
+__or__ = or_
+__pos__ = pos
+__pow__ = pow
+__rshift__ = rshift
+__sub__ = sub
+__truediv__ = truediv
+__xor__ = xor
+__concat__ = concat
+__contains__ = contains
+__delitem__ = delitem
+__getitem__ = getitem
+__setitem__ = setitem
+__iadd__ = iadd
+__iand__ = iand
+__iconcat__ = iconcat
+__ifloordiv__ = ifloordiv
+__ilshift__ = ilshift
+__imod__ = imod
+__imul__ = imul
+__imatmul__ = imatmul
+__ior__ = ior
+__ipow__ = ipow
+__irshift__ = irshift
+__isub__ = isub
+__itruediv__ = itruediv
+__ixor__ = ixor
+if sys.version_info >= (3, 11):
+    __call__ = call
+
+# At runtime, these classes are implemented in C as part of the _operator module
+# However, they consider themselves to live in the operator module, so we'll put
+# them here.
+@final
+class attrgetter(Generic[_T_co]):
+    @overload
+    def __new__(cls, attr: str, /) -> attrgetter[Any]: ...
+    @overload
+    def __new__(cls, attr: str, attr2: str, /) -> attrgetter[tuple[Any, Any]]: ...
+    @overload
+    def __new__(cls, attr: str, attr2: str, attr3: str, /) -> attrgetter[tuple[Any, Any, Any]]: ...
+    @overload
+    def __new__(cls, attr: str, attr2: str, attr3: str, attr4: str, /) -> attrgetter[tuple[Any, Any, Any, Any]]: ...
+    @overload
+    def __new__(cls, attr: str, /, *attrs: str) -> attrgetter[tuple[Any, ...]]: ...
+    def __call__(self, obj: Any, /) -> _T_co: ...
+
+@final
+class itemgetter(Generic[_T_co]):
+    @overload
+    def __new__(cls, item: _T, /) -> itemgetter[_T]: ...
+    @overload
+    def __new__(cls, item1: _T1, item2: _T2, /, *items: Unpack[_Ts]) -> itemgetter[tuple[_T1, _T2, Unpack[_Ts]]]: ...
+    # __key: _KT_contra in SupportsGetItem seems to be causing variance issues, ie:
+    # TypeVar "_KT_contra@SupportsGetItem" is contravariant
+    #   "tuple[int, int]" is incompatible with protocol "SupportsIndex"
+    # preventing [_T_co, ...] instead of [Any, ...]
+    #
+    # A suspected mypy issue prevents using [..., _T] instead of [..., Any] here.
+    # https://github.com/python/mypy/issues/14032
+    def __call__(self, obj: SupportsGetItem[Any, Any]) -> Any: ...
+
+@final
+class methodcaller:
+    def __init__(self, name: str, /, *args: Any, **kwargs: Any) -> None: ...
+    def __call__(self, obj: Any) -> Any: ...

{pyre_check_nightly-0.0.101729854749.data → pyre_check_nightly-0.0.101730373092.data}/data/lib/pyre_check/typeshed/stdlib/optparse.pyi

@@ -1,4 +1,4 @@
-from _typeshed import Incomplete
+from _typeshed import Incomplete, MaybeNone
 from abc import abstractmethod
 from collections.abc import Callable, Iterable, Mapping, Sequence
 from typing import IO, Any, AnyStr, Literal, NoReturn, overload
@@ -56,7 +56,7 @@ class HelpFormatter:
     current_indent: int
     default_tag: str
     help_position: int
-    help_width: int | Any  # initialized as None and computed later as int when storing option strings
+    help_width: int | MaybeNone  # initialized as None and computed later as int when storing option strings
     indent_increment: int
     level: int
     max_help_position: int

{pyre_check_nightly-0.0.101729854749.data → pyre_check_nightly-0.0.101730373092.data}/data/lib/pyre_check/typeshed/stdlib/os/__init__.pyi

@@ -23,8 +23,9 @@ from abc import abstractmethod
 from builtins import OSError
 from collections.abc import Callable, Iterable, Iterator, Mapping, MutableMapping, Sequence
 from contextlib import AbstractContextManager
-from io import BufferedRandom, BufferedReader, BufferedWriter, FileIO, TextIOWrapper as _TextIOWrapper
+from io import BufferedRandom, BufferedReader, BufferedWriter, FileIO, TextIOWrapper
 from subprocess import Popen
+from types import TracebackType
 from typing import (
     IO,
     Any,
@@ -574,7 +575,7 @@ def fdopen(
     newline: str | None = ...,
     closefd: bool = ...,
     opener: _Opener | None = ...,
-) -> _TextIOWrapper: ...
+) -> TextIOWrapper: ...
 @overload
 def fdopen(
     fd: int,
@@ -913,9 +914,25 @@ if sys.platform != "win32":
     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: ...
-    def close(self) -> int | None: ...  # type: ignore[override]
+class _wrap_close:
+    def __init__(self, stream: TextIOWrapper, proc: Popen[str]) -> None: ...
+    def close(self) -> int | None: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(
+        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
+    ) -> None: ...
+    def __iter__(self) -> Iterator[str]: ...
+    # Methods below here don't exist directly on the _wrap_close object, but
+    # are copied from the wrapped TextIOWrapper object via __getattr__.
+    # The full set of TextIOWrapper methods are technically available this way,
+    # but undocumented. Only a subset are currently included here.
+    def read(self, size: int | None = -1, /) -> str: ...
+    def readable(self) -> bool: ...
+    def readline(self, size: int = -1, /) -> str: ...
+    def readlines(self, hint: int = -1, /) -> list[str]: ...
+    def writable(self) -> bool: ...
+    def write(self, s: str, /) -> int: ...
+    def writelines(self, lines: Iterable[str], /) -> None: ...
 
 def popen(cmd: str, mode: str = "r", buffering: int = -1) -> _wrap_close: ...
 def spawnl(mode: int, file: StrOrBytesPath, arg0: StrOrBytesPath, *args: StrOrBytesPath) -> int: ...
@@ -1055,6 +1072,14 @@ if sys.platform != "win32":
 
 def cpu_count() -> int | None: ...
 
+if sys.version_info >= (3, 13):
+    # Documented to return `int | None`, but falls back to `len(sched_getaffinity(0))` when
+    # available. See https://github.com/python/cpython/blob/417c130/Lib/os.py#L1175-L1186.
+    if sys.platform != "win32" and sys.platform != "darwin":
+        def process_cpu_count() -> int: ...
+    else:
+        def process_cpu_count() -> int | None: ...
+
 if sys.platform != "win32":
     # Unix only
     def confstr(name: str | int, /) -> str | None: ...

{pyre_check_nightly-0.0.101729854749.data → pyre_check_nightly-0.0.101730373092.data}/data/lib/pyre_check/typeshed/stdlib/pickle.pyi

@@ -157,10 +157,10 @@ class Pickler:
     def __init__(
         self,
         file: SupportsWrite[bytes],
-        protocol: int | None = ...,
+        protocol: int | None = None,
         *,
-        fix_imports: bool = ...,
-        buffer_callback: _BufferCallback = ...,
+        fix_imports: bool = True,
+        buffer_callback: _BufferCallback = None,
     ) -> None: ...
     def reducer_override(self, obj: Any) -> Any: ...
     def dump(self, obj: Any, /) -> None: ...
@@ -174,10 +174,10 @@ class Unpickler:
         self,
         file: _ReadableFileobj,
         *,
-        fix_imports: bool = ...,
-        encoding: str = ...,
-        errors: str = ...,
-        buffers: Iterable[Any] | None = ...,
+        fix_imports: bool = True,
+        encoding: str = "ASCII",
+        errors: str = "strict",
+        buffers: Iterable[Any] | None = (),
     ) -> None: ...
     def load(self) -> Any: ...
     def find_class(self, module_name: str, global_name: str, /) -> Any: ...