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

pyre_check/__init__.py

@@ -3,4 +3,4 @@
 # This source code is licensed under the MIT license found in the
 # LICENSE file in the root directory of this source tree.
 
-__version__ = "0.0.101729854749"
+__version__ = "0.0.101730373092"

pyre_check/client/commands/pyre_language_server.py

@@ -145,13 +145,18 @@ class BuckTypeCheckStatus(enum.Enum):
     PARSE_ERROR = "parse_error"
     NOT_RUN = "not_run"
     PREEMPTED = "preempted"
+    PREEMPTED_SHOULD_RETRY = "preempted_should_retry"
 
     @classmethod
-    def from_returncode(cls, returncode: Optional[int]) -> BuckTypeCheckStatus:
+    def from_returncode(
+        cls, returncode: Optional[int], remaining_tasks: Optional[int] = None
+    ) -> BuckTypeCheckStatus:
         if returncode == 0:
             return BuckTypeCheckStatus.SUCCESS
         elif returncode == 3:
             return BuckTypeCheckStatus.USER_ERROR
+        elif returncode == 5 and remaining_tasks == 0:
+            return BuckTypeCheckStatus.PREEMPTED_SHOULD_RETRY
         elif returncode == 5:
             return BuckTypeCheckStatus.PREEMPTED
         else:
@@ -498,7 +503,7 @@ def log_exceptions_factory(
     return log_exceptions
 
 
-@dataclasses.dataclass(frozen=True)
+@dataclasses.dataclass
 class PyreLanguageServer(PyreLanguageServerApi):
     # Channel to send responses to the editor
     output_channel: connections.AsyncTextWriter
@@ -511,6 +516,7 @@ class PyreLanguageServer(PyreLanguageServerApi):
     index_querier: daemon_querier.AbstractDaemonQuerier
     document_formatter: Optional[AbstractDocumentFormatter]
     client_type_error_handler: type_error_handler.ClientTypeErrorHandler
+    ongoing_type_checks: int = 0
 
     async def write_telemetry(
         self,
@@ -724,14 +730,20 @@ class PyreLanguageServer(PyreLanguageServerApi):
                 file=argfile,
             )
             argfile.flush()
+            if (
+                self.get_language_server_features().type_errors_preemptible.is_enabled()
+                or self.get_language_server_features().per_target_isolation_dir.is_disabled()
+            ):
+                preemptible = [
+                    "--preemptible=ondifferentstate",
+                ]
+            else:
+                preemptible = []
             if self.get_language_server_features().per_target_isolation_dir.is_enabled():
                 isolation_dir = [f"--isolation-dir={PTT_ISOLATION_PREFIX}"]
-                preemptible = []
             else:
                 isolation_dir = []
-                preemptible = [
-                    "--preemptible=ondifferentstate",
-                ]
+
             type_check_parameters = [
                 "buck2",
                 *isolation_dir,
@@ -747,12 +759,16 @@ class PyreLanguageServer(PyreLanguageServerApi):
             LOG.debug(
                 f"Querying Buck for type errors: `{' '.join(type_check_parameters)}`"
             )
+
+            self.ongoing_type_checks += 1
             type_check = await asyncio.create_subprocess_exec(
                 *type_check_parameters,
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.PIPE,
             )
             stdout_data, stderr_data = await type_check.communicate()
+            self.ongoing_type_checks -= 1
+
             stdout_text = stdout_data.decode("utf-8")
             stderr_text = stderr_data.decode("utf-8")
             LOG.debug(f"Buck type check results:\n{stdout_text}\n{stderr_text}")
@@ -762,14 +778,20 @@ class PyreLanguageServer(PyreLanguageServerApi):
 
         error_message = None
         # return now if buck build was unsuccessful or not preempted
-        if type_check.returncode != 0:
-            if type_check.returncode != 5:
+        result_status = BuckTypeCheckStatus.from_returncode(
+            type_check.returncode, remaining_tasks=self.ongoing_type_checks
+        )
+        if result_status != BuckTypeCheckStatus.SUCCESS:
+            if result_status not in (
+                BuckTypeCheckStatus.PREEMPTED,
+                BuckTypeCheckStatus.PREEMPTED_SHOULD_RETRY,
+            ):
                 error_message = (
                     f"Got error exit code from Buck type check: {stderr_text}"
                 )
                 LOG.error(error_message)
             return PyreBuckTypeErrorMetadata(
-                status=BuckTypeCheckStatus.from_returncode(type_check.returncode),
+                status=result_status,
                 duration=buck_query_timer.stop_in_millisecond(),
                 type_errors={},
                 build_id=build_id,
@@ -822,7 +844,7 @@ class PyreLanguageServer(PyreLanguageServerApi):
             result = await self._query_buck_for_type_errors(
                 type_checkable_files, buck_query_timer, retries=retries
             )
-            if result.status != BuckTypeCheckStatus.PREEMPTED:
+            if result.status != BuckTypeCheckStatus.PREEMPTED_SHOULD_RETRY:
                 return result
 
         LOG.warning(
@@ -893,15 +915,17 @@ class PyreLanguageServer(PyreLanguageServerApi):
             LOG.debug(
                 f"Getting files for type checker from Buck: `{' '.join(query_parameters)}`"
             )
-            type_checked_files_query = asyncio.create_subprocess_exec(
+
+            self.ongoing_type_checks += 1
+            type_checked_files_query = await asyncio.create_subprocess_exec(
                 *query_parameters,
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.PIPE,
             )
-            awaited_files_query = await type_checked_files_query
-            stdout_data, stderr_data = await awaited_files_query.communicate()
+            stdout_data, stderr_data = await type_checked_files_query.communicate()
+            self.ongoing_type_checks -= 1
 
-        if awaited_files_query.returncode != 0:
+        if type_checked_files_query.returncode != 0:
             stderr = stderr_data.decode("utf-8")
             message = f"Typing query ended in error: {stderr}"
             LOG.error(message)
@@ -998,6 +1022,10 @@ class PyreLanguageServer(PyreLanguageServerApi):
                     "new_file_loaded": new_file_loaded,
                     "isolation_dir": isolation_dir,
                     "sharding_enabled": self.get_language_server_features().type_error_sharding.is_enabled(),
+                    "preemptible": (
+                        self.get_language_server_features().type_errors_preemptible.is_enabled()
+                        or self.get_language_server_features().per_target_isolation_dir.is_disabled()
+                    ),
                 },
                 **daemon_status_before.as_telemetry_dict(),
             },
@@ -1723,12 +1751,13 @@ class PyreLanguageServer(PyreLanguageServerApi):
             )
 
         try:
-            if self.document_formatter is None:
+            document_formatter = self.document_formatter
+            if document_formatter is None:
                 raise json_rpc.InternalError("Formatter was not initialized correctly.")
             else:
                 document_formatter_timer = timer.Timer()
-                document_formatting_response = (
-                    await self.document_formatter.format_document(document_path)
+                document_formatting_response = await document_formatter.format_document(
+                    document_path
                 )
 
                 raw_results = lsp.DocumentFormattingResponse.cached_schema().dump(
@@ -2307,7 +2336,7 @@ class PyreLanguageServer(PyreLanguageServerApi):
         )
 
 
-@dataclasses.dataclass(frozen=True)
+@dataclasses.dataclass
 class CodeNavigationServerApi(PyreLanguageServer):
     pass
 

pyre_check/client/language_server/features.py

@@ -100,6 +100,7 @@ FormattingAvailability = _Availability
 PerTargetTypeErrorsAvailability = CustomAvailability
 PerTargetIsolationDirAvailability = CustomAvailability
 TypeErrorShardingAvailability = CustomAvailability
+TypeErrorsPreemptibleAvailability = CustomAvailability
 PythonAutoTargetsAvailability = CustomAvailability
 SystemPyAutoTargetsAvailability = CustomAvailability
 # TODO: T204372341 remove this once we have rolled out addition and removal features
@@ -127,6 +128,9 @@ class LanguageServerFeatures:
     type_error_sharding: TypeErrorShardingAvailability = (
         TypeErrorShardingAvailability.from_enabled(False)
     )
+    type_errors_preemptible: TypeErrorsPreemptibleAvailability = (
+        TypeErrorsPreemptibleAvailability.from_enabled(False)
+    )
     unsaved_changes: UnsavedChangesAvailability = UnsavedChangesAvailability.DISABLED
     telemetry: TelemetryAvailability = TelemetryAvailability.DISABLED
     completion: CompletionAvailability = CompletionAvailability.DISABLED

pyre_check/client/version.py

@@ -1 +1 @@
-__version__ = "0.0.101729854749"
+__version__ = "0.0.101730373092"

{pyre_check_nightly-0.0.101729854749.data → pyre_check_nightly-0.0.101730373092.data}/data/lib/pyre_check/taint/core_privacy_security/general.pysa

@@ -22,7 +22,7 @@ def getattr(
 ): ...
 
 @SkipObscure
-def io.BytesIO.__init__(self, initial_bytes: TaintInTaintOut[Updates[self], Via[bytesio]]): ...
+def _io.BytesIO.__init__(self, initial_bytes: TaintInTaintOut[Updates[self], Via[bytesio]]): ...
 
 @SkipObscure
 def hmac.new(key: TaintInTaintOut[Via[hmac_key]], msg, digestmod): ...

pyre_check_nightly-0.0.101730373092.data/data/lib/pyre_check/taint/core_privacy_security/sqlite3_sinks.pysa

@@ -0,0 +1,6 @@
+def sqlite3.Cursor.execute(self, sql: TaintSink[SQL], parameters, /): ...
+def sqlite3.Cursor.executemany(self, sql: TaintSink[SQL], parameters, /): ...
+def sqlite3.Cursor.executescript(self, sql_script: TaintSink[SQL], /): ...
+def sqlite3.Connection.execute(self, sql: TaintSink[SQL], parameters, /): ...
+def sqlite3.Connection.executemany(self, sql: TaintSink[SQL], parameters, /): ...
+def sqlite3.Connection.executescript(self, sql_script: TaintSink[SQL], /): ...

{pyre_check_nightly-0.0.101729854749.data → pyre_check_nightly-0.0.101730373092.data}/data/lib/pyre_check/third_party_taint/authentication_sinks.pysa

@@ -1,8 +1,4 @@
 # Amazon S3
-def boto.s3.connection.S3Connection.__init__(
-    aws_access_key_id: TaintSink[Authentication] = ...,
-    aws_secret_access_key: TaintSink[Authentication] = ...,
-): ...
 def boto3.client(
     __aws_access_key_id: TaintSink[Authentication] = ...,
     __aws_secret_access_key: TaintSink[Authentication] = ...,

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

@@ -0,0 +1,149 @@
+import sys
+from ast import (
+    AST as AST,
+    Add as Add,
+    And as And,
+    AnnAssign as AnnAssign,
+    Assert as Assert,
+    Assign as Assign,
+    AsyncFor as AsyncFor,
+    AsyncFunctionDef as AsyncFunctionDef,
+    AsyncWith as AsyncWith,
+    Attribute as Attribute,
+    AugAssign as AugAssign,
+    Await as Await,
+    BinOp as BinOp,
+    BitAnd as BitAnd,
+    BitOr as BitOr,
+    BitXor as BitXor,
+    BoolOp as BoolOp,
+    Break as Break,
+    Call as Call,
+    ClassDef as ClassDef,
+    Compare as Compare,
+    Constant as Constant,
+    Continue as Continue,
+    Del as Del,
+    Delete as Delete,
+    Dict as Dict,
+    DictComp as DictComp,
+    Div as Div,
+    Eq as Eq,
+    ExceptHandler as ExceptHandler,
+    Expr as Expr,
+    Expression as Expression,
+    FloorDiv as FloorDiv,
+    For as For,
+    FormattedValue as FormattedValue,
+    FunctionDef as FunctionDef,
+    FunctionType as FunctionType,
+    GeneratorExp as GeneratorExp,
+    Global as Global,
+    Gt as Gt,
+    GtE as GtE,
+    If as If,
+    IfExp as IfExp,
+    Import as Import,
+    ImportFrom as ImportFrom,
+    In as In,
+    Interactive as Interactive,
+    Invert as Invert,
+    Is as Is,
+    IsNot as IsNot,
+    JoinedStr as JoinedStr,
+    Lambda as Lambda,
+    List as List,
+    ListComp as ListComp,
+    Load as Load,
+    LShift as LShift,
+    Lt as Lt,
+    LtE as LtE,
+    MatMult as MatMult,
+    Mod as Mod,
+    Module as Module,
+    Mult as Mult,
+    Name as Name,
+    NamedExpr as NamedExpr,
+    Nonlocal as Nonlocal,
+    Not as Not,
+    NotEq as NotEq,
+    NotIn as NotIn,
+    Or as Or,
+    Pass as Pass,
+    Pow as Pow,
+    Raise as Raise,
+    Return as Return,
+    RShift as RShift,
+    Set as Set,
+    SetComp as SetComp,
+    Slice as Slice,
+    Starred as Starred,
+    Store as Store,
+    Sub as Sub,
+    Subscript as Subscript,
+    Try as Try,
+    Tuple as Tuple,
+    TypeIgnore as TypeIgnore,
+    UAdd as UAdd,
+    UnaryOp as UnaryOp,
+    USub as USub,
+    While as While,
+    With as With,
+    Yield as Yield,
+    YieldFrom as YieldFrom,
+    alias as alias,
+    arg as arg,
+    arguments as arguments,
+    boolop as boolop,
+    cmpop as cmpop,
+    comprehension as comprehension,
+    excepthandler as excepthandler,
+    expr as expr,
+    expr_context as expr_context,
+    keyword as keyword,
+    mod as mod,
+    operator as operator,
+    stmt as stmt,
+    type_ignore as type_ignore,
+    unaryop as unaryop,
+    withitem as withitem,
+)
+from typing import Literal
+
+if sys.version_info >= (3, 12):
+    from ast import ParamSpec as ParamSpec, TypeVar as TypeVar, TypeVarTuple as TypeVarTuple, type_param as type_param
+
+if sys.version_info >= (3, 11):
+    from ast import TryStar as TryStar
+
+if sys.version_info >= (3, 10):
+    from ast import (
+        MatchAs as MatchAs,
+        MatchClass as MatchClass,
+        MatchMapping as MatchMapping,
+        MatchOr as MatchOr,
+        MatchSequence as MatchSequence,
+        MatchSingleton as MatchSingleton,
+        MatchStar as MatchStar,
+        MatchValue as MatchValue,
+        match_case as match_case,
+        pattern as pattern,
+    )
+
+if sys.version_info < (3, 9):
+    from ast import (
+        AugLoad as AugLoad,
+        AugStore as AugStore,
+        ExtSlice as ExtSlice,
+        Index as Index,
+        Param as Param,
+        Suite as Suite,
+        slice as slice,
+    )
+
+PyCF_ALLOW_TOP_LEVEL_AWAIT: Literal[8192]
+PyCF_ONLY_AST: Literal[1024]
+PyCF_TYPE_COMMENTS: Literal[4096]
+
+if sys.version_info >= (3, 13):
+    PyCF_OPTIMIZED_AST: Literal[33792]

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

@@ -0,0 +1,120 @@
+import sys
+from asyncio.events import AbstractEventLoop
+from collections.abc import Awaitable, Callable, Coroutine, Generator
+from contextvars import Context
+from types import FrameType
+from typing import Any, Literal, TextIO, TypeVar
+from typing_extensions import Self, TypeAlias
+
+if sys.version_info >= (3, 9):
+    from types import GenericAlias
+
+_T = TypeVar("_T")
+_T_co = TypeVar("_T_co", covariant=True)
+_TaskYieldType: TypeAlias = Future[object] | None
+
+class Future(Awaitable[_T]):
+    _state: str
+    @property
+    def _exception(self) -> BaseException | None: ...
+    _blocking: bool
+    @property
+    def _log_traceback(self) -> bool: ...
+    @_log_traceback.setter
+    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 get_loop(self) -> AbstractEventLoop: ...
+    @property
+    def _callbacks(self) -> list[tuple[Callable[[Self], Any], Context]]: ...
+    def add_done_callback(self, fn: Callable[[Self], object], /, *, context: Context | None = None) -> None: ...
+    if sys.version_info >= (3, 9):
+        def cancel(self, msg: Any | None = None) -> bool: ...
+    else:
+        def cancel(self) -> bool: ...
+
+    def cancelled(self) -> bool: ...
+    def done(self) -> bool: ...
+    def result(self) -> _T: ...
+    def exception(self) -> BaseException | None: ...
+    def remove_done_callback(self, fn: Callable[[Self], object], /) -> int: ...
+    def set_result(self, result: _T, /) -> None: ...
+    def set_exception(self, exception: type | BaseException, /) -> None: ...
+    def __iter__(self) -> Generator[Any, None, _T]: ...
+    def __await__(self) -> Generator[Any, None, _T]: ...
+    @property
+    def _loop(self) -> AbstractEventLoop: ...
+    if sys.version_info >= (3, 9):
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+
+if sys.version_info >= (3, 12):
+    _TaskCompatibleCoro: TypeAlias = Coroutine[Any, Any, _T_co]
+elif sys.version_info >= (3, 9):
+    _TaskCompatibleCoro: TypeAlias = Generator[_TaskYieldType, None, _T_co] | Coroutine[Any, Any, _T_co]
+else:
+    _TaskCompatibleCoro: TypeAlias = Generator[_TaskYieldType, None, _T_co] | Awaitable[_T_co]
+
+# mypy and pyright complain that a subclass of an invariant class shouldn't be covariant.
+# While this is true in general, here it's sort-of okay to have a covariant subclass,
+# since the only reason why `asyncio.Future` is invariant is the `set_result()` method,
+# and `asyncio.Task.set_result()` always raises.
+class Task(Future[_T_co]):  # type: ignore[type-var]  # pyright: ignore[reportInvalidTypeArguments]
+    if sys.version_info >= (3, 12):
+        def __init__(
+            self,
+            coro: _TaskCompatibleCoro[_T_co],
+            *,
+            loop: AbstractEventLoop = ...,
+            name: str | None = ...,
+            context: Context | None = None,
+            eager_start: bool = False,
+        ) -> None: ...
+    elif sys.version_info >= (3, 11):
+        def __init__(
+            self,
+            coro: _TaskCompatibleCoro[_T_co],
+            *,
+            loop: AbstractEventLoop = ...,
+            name: str | None = ...,
+            context: Context | None = None,
+        ) -> None: ...
+    else:
+        def __init__(
+            self, coro: _TaskCompatibleCoro[_T_co], *, loop: AbstractEventLoop = ..., name: str | None = ...
+        ) -> None: ...
+
+    if sys.version_info >= (3, 12):
+        def get_coro(self) -> _TaskCompatibleCoro[_T_co] | None: ...
+    else:
+        def get_coro(self) -> _TaskCompatibleCoro[_T_co]: ...
+
+    def get_name(self) -> str: ...
+    def set_name(self, value: object, /) -> None: ...
+    if sys.version_info >= (3, 12):
+        def get_context(self) -> Context: ...
+
+    def get_stack(self, *, limit: int | None = None) -> list[FrameType]: ...
+    def print_stack(self, *, limit: int | None = None, file: TextIO | None = None) -> None: ...
+    if sys.version_info >= (3, 11):
+        def cancelling(self) -> int: ...
+        def uncancel(self) -> int: ...
+    if sys.version_info < (3, 9):
+        @classmethod
+        def current_task(cls, loop: AbstractEventLoop | None = None) -> Task[Any] | None: ...
+        @classmethod
+        def all_tasks(cls, loop: AbstractEventLoop | None = None) -> set[Task[Any]]: ...
+    if sys.version_info >= (3, 9):
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+
+def get_event_loop() -> AbstractEventLoop: ...
+def get_running_loop() -> AbstractEventLoop: ...
+def _set_running_loop(loop: AbstractEventLoop | None, /) -> None: ...
+def _get_running_loop() -> AbstractEventLoop: ...
+def _register_task(task: Task[Any]) -> None: ...
+def _unregister_task(task: Task[Any]) -> None: ...
+def _enter_task(loop: AbstractEventLoop, task: Task[Any]) -> None: ...
+def _leave_task(loop: AbstractEventLoop, task: Task[Any]) -> None: ...
+
+if sys.version_info >= (3, 12):
+    def current_task(loop: AbstractEventLoop | None = None) -> Task[Any] | None: ...

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

@@ -0,0 +1,117 @@
+import sys
+from _typeshed import ReadableBuffer
+from typing import ClassVar, final
+from typing_extensions import Self
+
+BLAKE2B_MAX_DIGEST_SIZE: int = 64
+BLAKE2B_MAX_KEY_SIZE: int = 64
+BLAKE2B_PERSON_SIZE: int = 16
+BLAKE2B_SALT_SIZE: int = 16
+BLAKE2S_MAX_DIGEST_SIZE: int = 32
+BLAKE2S_MAX_KEY_SIZE: int = 32
+BLAKE2S_PERSON_SIZE: int = 8
+BLAKE2S_SALT_SIZE: int = 8
+
+@final
+class blake2b:
+    MAX_DIGEST_SIZE: ClassVar[int] = 64
+    MAX_KEY_SIZE: ClassVar[int] = 64
+    PERSON_SIZE: ClassVar[int] = 16
+    SALT_SIZE: ClassVar[int] = 16
+    block_size: int
+    digest_size: int
+    name: str
+    if sys.version_info >= (3, 9):
+        def __init__(
+            self,
+            data: ReadableBuffer = b"",
+            /,
+            *,
+            digest_size: int = 64,
+            key: ReadableBuffer = b"",
+            salt: ReadableBuffer = b"",
+            person: ReadableBuffer = b"",
+            fanout: int = 1,
+            depth: int = 1,
+            leaf_size: int = 0,
+            node_offset: int = 0,
+            node_depth: int = 0,
+            inner_size: int = 0,
+            last_node: bool = False,
+            usedforsecurity: bool = True,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            data: ReadableBuffer = b"",
+            /,
+            *,
+            digest_size: int = 64,
+            key: ReadableBuffer = b"",
+            salt: ReadableBuffer = b"",
+            person: ReadableBuffer = b"",
+            fanout: int = 1,
+            depth: int = 1,
+            leaf_size: int = 0,
+            node_offset: int = 0,
+            node_depth: int = 0,
+            inner_size: int = 0,
+            last_node: bool = False,
+        ) -> None: ...
+
+    def copy(self) -> Self: ...
+    def digest(self) -> bytes: ...
+    def hexdigest(self) -> str: ...
+    def update(self, data: ReadableBuffer, /) -> None: ...
+
+@final
+class blake2s:
+    MAX_DIGEST_SIZE: ClassVar[int] = 32
+    MAX_KEY_SIZE: ClassVar[int] = 32
+    PERSON_SIZE: ClassVar[int] = 8
+    SALT_SIZE: ClassVar[int] = 8
+    block_size: int
+    digest_size: int
+    name: str
+    if sys.version_info >= (3, 9):
+        def __init__(
+            self,
+            data: ReadableBuffer = b"",
+            /,
+            *,
+            digest_size: int = 32,
+            key: ReadableBuffer = b"",
+            salt: ReadableBuffer = b"",
+            person: ReadableBuffer = b"",
+            fanout: int = 1,
+            depth: int = 1,
+            leaf_size: int = 0,
+            node_offset: int = 0,
+            node_depth: int = 0,
+            inner_size: int = 0,
+            last_node: bool = False,
+            usedforsecurity: bool = True,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            data: ReadableBuffer = b"",
+            /,
+            *,
+            digest_size: int = 32,
+            key: ReadableBuffer = b"",
+            salt: ReadableBuffer = b"",
+            person: ReadableBuffer = b"",
+            fanout: int = 1,
+            depth: int = 1,
+            leaf_size: int = 0,
+            node_offset: int = 0,
+            node_depth: int = 0,
+            inner_size: int = 0,
+            last_node: bool = False,
+        ) -> None: ...
+
+    def copy(self) -> Self: ...
+    def digest(self) -> bytes: ...
+    def hexdigest(self) -> str: ...
+    def update(self, data: ReadableBuffer, /) -> None: ...

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

@@ -1,3 +1,4 @@
+import csv
 import sys
 from _typeshed import SupportsWrite
 from collections.abc import Iterable, Iterator
@@ -20,7 +21,7 @@ _QuotingType: TypeAlias = int
 
 class Error(Exception): ...
 
-_DialectLike: TypeAlias = str | Dialect | type[Dialect]
+_DialectLike: TypeAlias = str | Dialect | csv.Dialect | type[Dialect | csv.Dialect]
 
 class Dialect:
     delimiter: str

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

@@ -2,7 +2,7 @@ import sys
 from _typeshed import ReadableBuffer, WriteableBuffer
 from abc import abstractmethod
 from collections.abc import Callable, Iterable, Iterator, Mapping, Sequence
-from ctypes import CDLL, ArgumentError as ArgumentError
+from ctypes import CDLL, ArgumentError as ArgumentError, c_void_p
 from typing import Any, ClassVar, Generic, TypeVar, overload
 from typing_extensions import Self, TypeAlias
 
@@ -99,6 +99,9 @@ class _Pointer(_PointerLike, _CData, Generic[_CT]):
     def __getitem__(self, key: slice, /) -> list[Any]: ...
     def __setitem__(self, key: int, value: Any, /) -> None: ...
 
+@overload
+def POINTER(type: None, /) -> type[c_void_p]: ...
+@overload
 def POINTER(type: type[_CT], /) -> type[_Pointer[_CT]]: ...
 def pointer(obj: _CT, /) -> _Pointer[_CT]: ...