GH-130328: further speedup of pasting in new REPL on Windows by reading in chunks

Lib/_pyrepl/windows_console.py

@@ -22,8 +22,6 @@
 import io
 import os
 import sys
-import time
-import msvcrt
 
 import ctypes
 from ctypes.wintypes import (
@@ -44,14 +42,17 @@
 from .windows_eventqueue import EventQueue
 
 try:
-    from ctypes import GetLastError, WinDLL, windll, WinError  # type: ignore[attr-defined]
+    from ctypes import get_last_error, GetLastError, WinDLL, windll, WinError  # type: ignore[attr-defined]
 except:
     # Keep MyPy happy off Windows
     from ctypes import CDLL as WinDLL, cdll as windll
 
     def GetLastError() -> int:
         return 42
 
+    def get_last_error() -> int:
+        return 42
+
     class WinError(OSError):  # type: ignore[no-redef]
         def __init__(self, err: int | None, descr: str | None = None) -> None:
             self.err = err
@@ -63,6 +64,8 @@ def __init__(self, err: int | None, descr: str | None = None) -> None:
 if TYPE_CHECKING:
     from typing import IO
 
+INPUT_BUFFER_LEN = 10 * 1024
+
 # Virtual-Key Codes: https://learn.microsoft.com/en-us/windows/win32/inputdev/virtual-key-codes
 VK_MAP: dict[int, str] = {
     0x23: "end",  # VK_END
@@ -108,6 +111,12 @@ def __init__(self, err: int | None, descr: str | None = None) -> None:
 ALT_ACTIVE = 0x01 | 0x02
 CTRL_ACTIVE = 0x04 | 0x08
 
+WAIT_TIMEOUT = 0x102
+WAIT_FAILED = 0xFFFFFFFF
+
+# from winbase.h
+INFINITE = 0xFFFFFFFF
+
 
 class _error(Exception):
     pass
@@ -158,6 +167,10 @@ def __init__(
             # Console I/O is redirected, fallback...
             self.out = None
 
+        self.input_buffer = (INPUT_RECORD * INPUT_BUFFER_LEN)()
+        self.input_buffer_pos = 0
+        self.input_buffer_count = 0
+
     def refresh(self, screen: list[str], c_xy: tuple[int, int]) -> None:
         """
         Refresh the console screen.
@@ -408,20 +421,27 @@ def _getscrollbacksize(self) -> int:
 
         return info.srWindow.Bottom  # type: ignore[no-any-return]
 
+    def more_in_buffer(self) -> bool:
+        return self.input_buffer_pos < self.input_buffer_count - 1
+
     def _read_input(self, block: bool = True) -> INPUT_RECORD | None:
-        if not block:
-            events = DWORD()
-            if not GetNumberOfConsoleInputEvents(InHandle, events):
-                raise WinError(GetLastError())
-            if not events.value:
-                return None
+        if not block and not self.wait(timeout=0):
+            return None
+
+        if self.more_in_buffer():
+            self.input_buffer_pos += 1
+            return self.input_buffer[self.input_buffer_pos]
 
-        rec = INPUT_RECORD()
+        # read next chunk
+        self.input_buffer_pos = 0
+        self.input_buffer_count = 0
         read = DWORD()
-        if not ReadConsoleInput(InHandle, rec, 1, read):
+
+        if not ReadConsoleInput(InHandle, self.input_buffer, INPUT_BUFFER_LEN, read):
             raise WinError(GetLastError())
 
-        return rec
+        self.input_buffer_count = read.value
+        return self.input_buffer[0]
 
     def get_event(self, block: bool = True) -> Event | None:
         """Return an Event instance.  Returns None if |block| is false
@@ -518,18 +538,37 @@ def forgetinput(self) -> None:
     def getpending(self) -> Event:
         """Return the characters that have been typed but not yet
         processed."""
-        return Event("key", "", b"")
+        e = Event("key", "", b"")
+
+        while not self.event_queue.empty():
+            e2 = self.event_queue.get()
+            e.data += e2.data
+            e.raw += e.raw
+
+        return e
 
-    def wait(self, timeout: float | None) -> bool:
+    def wait_for_event(self, timeout: float | None) -> bool:
         """Wait for an event."""
-        # Poor man's Windows select loop
-        start_time = time.time()
-        while True:
-            if msvcrt.kbhit(): # type: ignore[attr-defined]
-                return True
-            if timeout and time.time() - start_time > timeout / 1000:
-                return False
-            time.sleep(0.01)
+        if timeout is None:
+            timeout = INFINITE
+        else:
+            timeout = int(timeout)
+        ret = WaitForSingleObject(InHandle, timeout)
+        if ret == WAIT_FAILED:
+            raise WinError(get_last_error())
+        elif ret == WAIT_TIMEOUT:
+            return False
+        return True
+
+    def wait(self, timeout: float | None = None) -> bool:
+        """
+        Wait for events on the console.
+        """
+        return (
+            not self.event_queue.empty()
+            or self.more_in_buffer()
+            or self.wait_for_event(timeout)
+        )
 
     def repaint(self) -> None:
         raise NotImplementedError("No repaint support")
@@ -649,14 +688,15 @@ class INPUT_RECORD(Structure):
     ReadConsoleInput.argtypes = [HANDLE, POINTER(INPUT_RECORD), DWORD, POINTER(DWORD)]
     ReadConsoleInput.restype = BOOL
 
-    GetNumberOfConsoleInputEvents = _KERNEL32.GetNumberOfConsoleInputEvents
-    GetNumberOfConsoleInputEvents.argtypes = [HANDLE, POINTER(DWORD)]
-    GetNumberOfConsoleInputEvents.restype = BOOL
 
     FlushConsoleInputBuffer = _KERNEL32.FlushConsoleInputBuffer
     FlushConsoleInputBuffer.argtypes = [HANDLE]
     FlushConsoleInputBuffer.restype = BOOL
 
+    WaitForSingleObject = _KERNEL32.WaitForSingleObject
+    WaitForSingleObject.argtypes = [HANDLE, DWORD]
+    WaitForSingleObject.restype = DWORD
+
     OutHandle = GetStdHandle(STD_OUTPUT_HANDLE)
     InHandle = GetStdHandle(STD_INPUT_HANDLE)
 else:
@@ -670,7 +710,7 @@ def _win_only(*args, **kwargs):
     GetConsoleMode = _win_only
     SetConsoleMode = _win_only
     ReadConsoleInput = _win_only
-    GetNumberOfConsoleInputEvents = _win_only
     FlushConsoleInputBuffer = _win_only
+    WaitForSingleObject = _win_only
     OutHandle = 0
     InHandle = 0

Misc/NEWS.d/next/Library/2025-04-24-18-07-49.gh-issue-130328.z7CN8z.rst

@@ -0,0 +1 @@
+Speedup pasting in ``PyREPL`` on Windows. Fix by Chris Eibl.