bounded_subprocess 2.0.0__tar.gz → 2.2.0__tar.gz

{bounded_subprocess-2.0.0 → bounded_subprocess-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bounded_subprocess
-Version: 2.0.0
+Version: 2.2.0
 Summary: A library to facilitate running subprocesses that may misbehave.
 Project-URL: Homepage, https://github.com/arjunguha/bounded_subprocess
 Project-URL: Bug Tracker, https://github.com/arjunguha/bounded_subprocess

{bounded_subprocess-2.0.0 → bounded_subprocess-2.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bounded_subprocess"
-version = "2.0.0"
+version = "2.2.0"
 authors = [
   { name="Arjun Guha" },
   { name="Ming-Ho Yee" },

{bounded_subprocess-2.0.0 → bounded_subprocess-2.2.0}/src/bounded_subprocess/bounded_subprocess.py

@@ -1,7 +1,13 @@
 import time
-from typing import List
+from typing import List, Optional
 
-from .util import Result, BoundedSubprocessState, SLEEP_BETWEEN_READS
+from .util import (
+    Result,
+    BoundedSubprocessState,
+    SLEEP_BETWEEN_READS,
+    write_loop_sync,
+    _STDIN_WRITE_TIMEOUT,
+)
 
 
 def run(
@@ -9,13 +15,22 @@ def run(
     timeout_seconds: int = 15,
     max_output_size: int = 2048,
     env=None,
+    stdin_data: Optional[str] = None,
 ) -> Result:
     """
     Runs the given program with arguments. After the timeout elapses, kills the process
     and all other processes in the process group. Captures at most max_output_size bytes
     of stdout and stderr each, and discards any output beyond that.
     """
-    state = BoundedSubprocessState(args, env, max_output_size)
+    state = BoundedSubprocessState(args, env, max_output_size, stdin_data is not None)
+    if stdin_data is not None:
+        write_loop_sync(
+            state.write_chunk,
+            stdin_data.encode(),
+            _STDIN_WRITE_TIMEOUT,
+            sleep_interval=SLEEP_BETWEEN_READS,
+        )
+        state.close_stdin()
 
     # We sleep for 0.1 seconds in each iteration.
     max_iterations = timeout_seconds * 10
@@ -27,4 +42,4 @@ def run(
         else:
             break
 
-    return state.terminate()
+    return state.terminate()

{bounded_subprocess-2.0.0 → bounded_subprocess-2.2.0}/src/bounded_subprocess/bounded_subprocess_async.py

@@ -1,6 +1,12 @@
 import asyncio
-from typing import List
-from .util import Result, BoundedSubprocessState, SLEEP_BETWEEN_READS
+from typing import List, Optional
+from .util import (
+    Result,
+    BoundedSubprocessState,
+    SLEEP_BETWEEN_READS,
+    write_loop_async,
+    _STDIN_WRITE_TIMEOUT,
+)
 
 
 async def run(
@@ -8,6 +14,7 @@ async def run(
     timeout_seconds: int = 15,
     max_output_size: int = 2048,
     env=None,
+    stdin_data: Optional[str] = None,
 ) -> Result:
     """
     Runs the given program with arguments. After the timeout elapses, kills the process
@@ -18,7 +25,15 @@ async def run(
     # were going to use asyncio.create_subprocess_exec. But, we're not. We're
     # using subprocess.Popen because it supports non-blocking reads. What's
     # async here? It's just the sleep between reads.
-    state = BoundedSubprocessState(args, env, max_output_size)
+    state = BoundedSubprocessState(args, env, max_output_size, stdin_data is not None)
+    if stdin_data is not None:
+        await write_loop_async(
+            state.write_chunk,
+            stdin_data.encode(),
+            _STDIN_WRITE_TIMEOUT,
+            sleep_interval=SLEEP_BETWEEN_READS,
+        )
+        await state.close_stdin_async(_STDIN_WRITE_TIMEOUT)
 
     # We sleep for 0.1 seconds in each iteration.
     max_iterations = timeout_seconds * 10
@@ -31,3 +46,4 @@ async def run(
             break
 
     return state.terminate()
+

bounded_subprocess-2.2.0/src/bounded_subprocess/interactive.py

@@ -0,0 +1,124 @@
+from typeguard import typechecked
+from typing import List, Optional
+import time
+import errno
+import subprocess
+from .util import set_nonblocking, MAX_BYTES_PER_READ, write_loop_sync
+
+_SLEEP_AFTER_WOUND_BLOCK = 0.5
+
+
+class _InteractiveState:
+    """Shared implementation for synchronous and asynchronous interaction."""
+
+    def __init__(self, args: List[str], read_buffer_size: int) -> None:
+        popen = subprocess.Popen(
+            args,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            bufsize=MAX_BYTES_PER_READ,
+        )
+        set_nonblocking(popen.stdin)
+        set_nonblocking(popen.stdout)
+        self.popen = popen
+        self.read_buffer_size = read_buffer_size
+        self.stdout_saved_bytes = bytearray()
+
+    # --- low level helpers -------------------------------------------------
+    def poll(self) -> Optional[int]:
+        return self.popen.poll()
+
+    def close_pipes(self) -> None:
+        try:
+            self.popen.stdin.close()
+        except BlockingIOError:
+            pass
+        self.popen.stdout.close()
+
+    def kill(self) -> None:
+        self.popen.kill()
+
+    def return_code(self) -> int:
+        rc = self.popen.returncode
+        return rc if rc is not None else -9
+
+    def write_chunk(self, data: memoryview) -> tuple[int, bool]:
+        try:
+            written = self.popen.stdin.write(data)
+            self.popen.stdin.flush()
+            return written, True
+        except BlockingIOError as exn:
+            if exn.errno != errno.EAGAIN:
+                return exn.characters_written, False
+            return exn.characters_written, True
+        except BrokenPipeError:
+            return 0, False
+
+    def read_chunk(self) -> Optional[bytes]:
+        return self.popen.stdout.read(MAX_BYTES_PER_READ)
+
+    def pop_line(self, start_idx: int) -> Optional[bytes]:
+        newline_index = self.stdout_saved_bytes.find(b"\n", start_idx)
+        if newline_index == -1:
+            return None
+        line = memoryview(self.stdout_saved_bytes)[:newline_index].tobytes()
+        del self.stdout_saved_bytes[: newline_index + 1]
+        return line
+
+    def append_stdout(self, data: bytes) -> None:
+        self.stdout_saved_bytes.extend(data)
+
+    def trim_stdout(self) -> None:
+        if len(self.stdout_saved_bytes) > self.read_buffer_size:
+            del self.stdout_saved_bytes[: len(self.stdout_saved_bytes) - self.read_buffer_size]
+
+
+@typechecked
+class Interactive:
+    """Interact with a subprocess using non-blocking I/O."""
+
+    def __init__(self, args: List[str], read_buffer_size: int) -> None:
+        self._state = _InteractiveState(args, read_buffer_size)
+
+    def close(self, nice_timeout_seconds: int) -> int:
+        self._state.close_pipes()
+        for _ in range(nice_timeout_seconds):
+            if self._state.poll() is not None:
+                break
+            time.sleep(1)
+        self._state.kill()
+        return self._state.return_code()
+
+    def write(self, stdin_data: bytes, timeout_seconds: int) -> bool:
+        if self._state.poll() is not None:
+            return False
+        return write_loop_sync(
+            self._state.write_chunk,
+            stdin_data,
+            timeout_seconds,
+            sleep_interval=_SLEEP_AFTER_WOUND_BLOCK,
+        )
+
+    def read_line(self, timeout_seconds: int) -> Optional[bytes]:
+        line = self._state.pop_line(0)
+        if line is not None:
+            return line
+        if self._state.poll() is not None:
+            return None
+        deadline = time.time() + timeout_seconds
+        while time.time() < deadline:
+            new_bytes = self._state.read_chunk()
+            if new_bytes is None:
+                time.sleep(_SLEEP_AFTER_WOUND_BLOCK)
+                continue
+            if len(new_bytes) == 0:
+                return None
+            prev_len = len(self._state.stdout_saved_bytes)
+            self._state.append_stdout(new_bytes)
+            line = self._state.pop_line(prev_len)
+            if line is not None:
+                return line
+            self._state.trim_stdout()
+            time.sleep(_SLEEP_AFTER_WOUND_BLOCK)
+        return None
+

bounded_subprocess-2.2.0/src/bounded_subprocess/interactive_async.py

@@ -0,0 +1,58 @@
+from typeguard import typechecked
+from typing import List, Optional
+import asyncio
+import time
+
+from .interactive import _InteractiveState, _SLEEP_AFTER_WOUND_BLOCK
+from .util import write_loop_async
+
+
+@typechecked
+class Interactive:
+    """Asynchronous interface for interacting with a subprocess."""
+
+    def __init__(self, args: List[str], read_buffer_size: int) -> None:
+        self._state = _InteractiveState(args, read_buffer_size)
+
+    async def close(self, nice_timeout_seconds: int) -> int:
+        self._state.close_pipes()
+        for _ in range(nice_timeout_seconds):
+            if self._state.poll() is not None:
+                break
+            await asyncio.sleep(1)
+        self._state.kill()
+        return self._state.return_code()
+
+    async def write(self, stdin_data: bytes, timeout_seconds: int) -> bool:
+        if self._state.poll() is not None:
+            return False
+        return await write_loop_async(
+            self._state.write_chunk,
+            stdin_data,
+            timeout_seconds,
+            sleep_interval=_SLEEP_AFTER_WOUND_BLOCK,
+        )
+
+    async def read_line(self, timeout_seconds: int) -> Optional[bytes]:
+        line = self._state.pop_line(0)
+        if line is not None:
+            return line
+        if self._state.poll() is not None:
+            return None
+        deadline = time.time() + timeout_seconds
+        while time.time() < deadline:
+            new_bytes = self._state.read_chunk()
+            if new_bytes is None:
+                await asyncio.sleep(_SLEEP_AFTER_WOUND_BLOCK)
+                continue
+            if len(new_bytes) == 0:
+                return None
+            prev_len = len(self._state.stdout_saved_bytes)
+            self._state.append_stdout(new_bytes)
+            line = self._state.pop_line(prev_len)
+            if line is not None:
+                return line
+            self._state.trim_stdout()
+            await asyncio.sleep(_SLEEP_AFTER_WOUND_BLOCK)
+        return None
+

{bounded_subprocess-2.0.0 → bounded_subprocess-2.2.0}/src/bounded_subprocess/util.py

@@ -2,9 +2,14 @@ import subprocess
 import os
 import fcntl
 import signal
+from typing import Callable, Optional
+import errno
+import time
+import asyncio
 
 MAX_BYTES_PER_READ = 1024
 SLEEP_BETWEEN_READS = 0.1
+_STDIN_WRITE_TIMEOUT = 3
 
 
 class Result:
@@ -26,20 +31,79 @@ def set_nonblocking(reader):
     fcntl.fcntl(fd, fcntl.F_SETFL, fl | os.O_NONBLOCK)
 
 
+def popen_write_chunk(p: subprocess.Popen, data: memoryview) -> tuple[int, bool]:
+    """Try writing a chunk of bytes to a non-blocking Popen stdin."""
+    try:
+        written = p.stdin.write(data)
+        p.stdin.flush()
+        if written is None:
+            written = 0
+        return written, True
+    except BlockingIOError as exn:
+        if exn.errno != errno.EAGAIN:
+            return exn.characters_written, False
+        return exn.characters_written, True
+    except BrokenPipeError:
+        return 0, False
+
+
+def write_loop_sync(
+    write_chunk: Callable[[memoryview], tuple[int, bool]],
+    data: bytes,
+    timeout_seconds: float,
+    *,
+    sleep_interval: float,
+) -> bool:
+    """Repeatedly write data using write_chunk until complete or timeout."""
+    mv = memoryview(data)
+    start = 0
+    start_time = time.time()
+    while start < len(mv):
+        written, keep_going = write_chunk(mv[start:])
+        start += written
+        if not keep_going:
+            return False
+        if start < len(mv):
+            if time.time() - start_time > timeout_seconds:
+                return False
+            time.sleep(sleep_interval)
+    return True
+
+
+async def write_loop_async(
+    write_chunk: Callable[[memoryview], tuple[int, bool]],
+    data: bytes,
+    timeout_seconds: float,
+    *,
+    sleep_interval: float,
+) -> bool:
+    """Asynchronously write data until complete or timeout."""
+    mv = memoryview(data)
+    start = 0
+    start_time = time.time()
+    while start < len(mv):
+        written, keep_going = write_chunk(mv[start:])
+        start += written
+        if not keep_going:
+            return False
+        if start < len(mv):
+            if time.time() - start_time > timeout_seconds:
+                return False
+            await asyncio.sleep(sleep_interval)
+    return True
+
+
 class BoundedSubprocessState:
-    """
-    This class lets us share code between the synchronous and asynchronous
-    implementations.
-    """
+    """State shared between synchronous and asynchronous subprocess helpers."""
 
-    def __init__(self, args, env, max_output_size):
+    def __init__(self, args, env, max_output_size, use_stdin_pipe: bool = False):
         """
         Start the process in a new session.
         """
         p = subprocess.Popen(
             args,
             env=env,
-            stdin=subprocess.DEVNULL,
+            stdin=subprocess.PIPE if use_stdin_pipe else subprocess.DEVNULL,
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
             start_new_session=True,
@@ -47,6 +111,8 @@ class BoundedSubprocessState:
         )
         set_nonblocking(p.stdout)
         set_nonblocking(p.stderr)
+        if use_stdin_pipe:
+            set_nonblocking(p.stdin)
 
         self.process_group_id = os.getpgid(p.pid)
         self.p = p
@@ -57,6 +123,44 @@ class BoundedSubprocessState:
         self.stderr_bytes_read = 0
         self.max_output_size = max_output_size
 
+    def write_chunk(self, data: memoryview) -> tuple[int, bool]:
+        if self.p.stdin is None:
+            return 0, False
+        try:
+            written = self.p.stdin.write(data)
+            self.p.stdin.flush()
+            if written is None:
+                written = 0
+            return written, True
+        except BlockingIOError as exn:
+            if exn.errno != errno.EAGAIN:
+                return exn.characters_written, False
+            return exn.characters_written, True
+        except BrokenPipeError:
+            return 0, False
+
+    def close_stdin(self) -> None:
+        if self.p.stdin is None:
+            return
+        try:
+            self.p.stdin.close()
+        except BrokenPipeError:
+            pass
+
+    async def close_stdin_async(self, timeout: int) -> None:
+        if self.p.stdin is None:
+            return
+        for _ in range(timeout):
+            try:
+                self.p.stdin.close()
+                return
+            except BlockingIOError:
+                await asyncio.sleep(1)
+            except BrokenPipeError:
+                return
+
+
+
     def try_read(self) -> bool:
         """
         Reads from the process. Returning False indicates that we should stop

bounded_subprocess-2.2.0/test/evil_programs/echo_stdin.py

@@ -0,0 +1,4 @@
+import sys
+
+data = sys.stdin.read()
+print(data, end="")

{bounded_subprocess-2.0.0 → bounded_subprocess-2.2.0}/test/module_test.py

@@ -116,4 +116,33 @@ def test_long_stdout():
     assert result.timeout == False
     # leave some leeway space for encoding
     assert 9500 <= len(result.stdout) <= 10500
+    assert_no_running_evil()
+
+
+def test_stdin_data_does_not_read():
+    data = "hello world\n"
+    result = run(
+        ["python3", ROOT / "does_not_read.py"],
+        timeout_seconds=2,
+        max_output_size=1024,
+        stdin_data=data,
+    )
+    assert result.exit_code == -1
+    assert result.timeout is True
+    assert len(result.stdout) == 0
+    assert len(result.stderr) == 0
+    assert_no_running_evil()
+
+
+def test_stdin_data_echo():
+    data = "hello world\n"
+    result = run(
+        ["python3", ROOT / "echo_stdin.py"],
+        timeout_seconds=2,
+        max_output_size=1024,
+        stdin_data=data,
+    )
+    assert result.exit_code == 0
+    assert result.timeout is False
+    assert result.stdout == data
     assert_no_running_evil()

{bounded_subprocess-2.0.0 → bounded_subprocess-2.2.0}/test/test_async.py

@@ -72,3 +72,34 @@ async def test_concurrent_sleep():
     assert all(len(r.stderr) == 0 for r in results)
     assert time.time() - start_time < 1.1
     await assert_no_running_evil()
+
+
+@pytest.mark.asyncio
+async def test_stdin_data_async_does_not_read():
+    data = "hello async\n"
+    result = await run(
+        ["python3", ROOT / "does_not_read.py"],
+        timeout_seconds=2,
+        max_output_size=1024,
+        stdin_data=data,
+    )
+    assert result.exit_code == -1
+    assert result.timeout is True
+    assert len(result.stdout) == 0
+    assert len(result.stderr) == 0
+    await assert_no_running_evil()
+
+
+@pytest.mark.asyncio
+async def test_stdin_data_async_echo():
+    data = "hello async\n"
+    result = await run(
+        ["python3", ROOT / "echo_stdin.py"],
+        timeout_seconds=2,
+        max_output_size=1024,
+        stdin_data=data,
+    )
+    assert result.exit_code == 0
+    assert result.timeout is False
+    assert result.stdout == data
+    await assert_no_running_evil()

bounded_subprocess-2.0.0/src/bounded_subprocess/interactive.py

@@ -1,131 +0,0 @@
-from typeguard import typechecked
-from typing import List, Optional
-import time
-import errno
-import subprocess
-from .util import set_nonblocking
-
-
-_MAX_BYTES_PER_READ = 1024
-_SLEEP_AFTER_WOUND_BLOCK = 0.5
-
-
-@typechecked
-class Interactive:
-    """
-    A class for interacting with a subprocess that is careful to use non-blocking
-    I/O so that we can timeout reads and writes.
-    """
-
-    def __init__(self, args: List[str], read_buffer_size: int):
-        """
-        read_buffer_size is the maximum number of bytes to read from stdout
-        and stdout each. If the process writes more than this, the extra bytes
-        will be discarded.
-        """
-        popen = subprocess.Popen(
-            args,
-            stdin=subprocess.PIPE,
-            stdout=subprocess.PIPE,
-            # stderr=subprocess.PIPE,
-            bufsize=_MAX_BYTES_PER_READ,
-        )
-        set_nonblocking(popen.stdin)
-        set_nonblocking(popen.stdout)
-        self._read_buffer_size = read_buffer_size
-        self._stdout_saved_bytes = bytearray()
-        self._stderr_saved_bytes = bytearray()
-        self._popen = popen
-
-    def close(self, nice_timeout_seconds: int) -> int:
-        """
-        Close the process and wait for it to exit.
-        """
-        try:
-            self._popen.stdin.close()
-        except BlockingIOError:
-            # .close() will attempt to flush any buffered writes to stdout
-            # before the close returns. This may block, but since the file
-            # descriptor is non-blocking, we get a BlockingIOError.
-            pass
-        self._popen.stdout.close()
-        for _ in range(nice_timeout_seconds):
-            if self._popen.poll() is not None:
-                break
-            time.sleep(1)
-        self._popen.kill()
-        return_code = self._popen.returncode
-        return return_code if return_code is not None else -9
-
-    def write(self, stdin_data: bytes, timeout_seconds: int):
-        """
-        Write data to the process's stdin.
-        """
-        if self._popen.poll() is not None:
-            return False
-
-        write_start_index = 0
-        start_time = time.time()
-        while write_start_index < len(stdin_data):
-            try:
-                bytes_written = self._popen.stdin.write(stdin_data[write_start_index:])
-                self._popen.stdin.flush()
-            except BlockingIOError as exn:
-                if exn.errno != errno.EAGAIN:
-                    return False
-                bytes_written = exn.characters_written
-                time.sleep(_SLEEP_AFTER_WOUND_BLOCK)
-            except BrokenPipeError:
-                # The child has closed stdin. It is likely dead.
-                return False
-            write_start_index += bytes_written
-            if time.time() - start_time > timeout_seconds:
-                return False
-        return True
-
-    def _read_line_from_saved_bytes(self, newline_search_index: int) -> Optional[bytes]:
-        """
-        Try to read a line of output from the buffer of stdout that this object
-        manages itself. The newline_search_index to indicate where to  start
-        looking for b"\n". Typically will be 0, but there are cases where we
-        are certain that the the newline is not in a prefix.
-        """
-        newline_index = self._stdout_saved_bytes.find(b"\n", newline_search_index)
-        if newline_index == -1:
-            return None
-        # memoryview helps avoid a pointless copy
-        line = memoryview(self._stdout_saved_bytes)[:newline_index].tobytes()
-        del self._stdout_saved_bytes[: newline_index + 1]
-        return line
-
-    def read_line(self, timeout_seconds: int) -> Optional[bytes]:
-        """
-        Read a line from the process's stdout.
-        """
-        from_saved_bytes = self._read_line_from_saved_bytes(0)
-        if from_saved_bytes is not None:
-            return from_saved_bytes
-        if self._popen.poll() is not None:
-            return None
-        deadline = time.time() + timeout_seconds
-        while time.time() < deadline:
-            new_bytes = self._popen.stdout.read(_MAX_BYTES_PER_READ)
-            # If the read would block, we get None and not zero bytes on MacOS.
-            if new_bytes is None:
-                time.sleep(_SLEEP_AFTER_WOUND_BLOCK)
-                continue
-            # If we read 0 bytes, the child has closed stdout and is likely dead.
-            if len(new_bytes) == 0:
-                return None
-            prev_saved_bytes_len = len(self._stdout_saved_bytes)
-            self._stdout_saved_bytes.extend(new_bytes)
-            from_saved_bytes = self._read_line_from_saved_bytes(prev_saved_bytes_len)
-            if from_saved_bytes is not None:
-                return from_saved_bytes
-            if len(self._stdout_saved_bytes) > self._read_buffer_size:
-                del self._stdout_saved_bytes[
-                    : len(self._stdout_saved_bytes) - self._read_buffer_size
-                ]
-            time.sleep(_SLEEP_AFTER_WOUND_BLOCK)
-
-        return None

bounded_subprocess-2.0.0/src/bounded_subprocess/interactive_async.py

@@ -1,131 +0,0 @@
-from typeguard import typechecked
-from typing import List, Optional
-import time
-import errno
-import subprocess
-from .util import set_nonblocking
-import asyncio
-
-_MAX_BYTES_PER_READ = 1024
-_SLEEP_AFTER_WOUND_BLOCK = 0.5
-
-
-@typechecked
-class Interactive:
-    """
-    A class for interacting with a subprocess that is careful to use non-blocking
-    I/O so that we can timeout reads and writes.
-    """
-
-    def __init__(self, args: List[str], read_buffer_size: int):
-        """
-        read_buffer_size is the maximum number of bytes to read from stdout
-        and stdout each. If the process writes more than this, the extra bytes
-        will be discarded.
-        """
-        popen = subprocess.Popen(
-            args,
-            stdin=subprocess.PIPE,
-            stdout=subprocess.PIPE,
-            # stderr=subprocess.PIPE,
-            bufsize=_MAX_BYTES_PER_READ,
-        )
-        set_nonblocking(popen.stdin)
-        set_nonblocking(popen.stdout)
-        self._read_buffer_size = read_buffer_size
-        self._stdout_saved_bytes = bytearray()
-        self._stderr_saved_bytes = bytearray()
-        self._popen = popen
-
-    async def close(self, nice_timeout_seconds: int) ->  int:
-        """
-        Close the process and wait for it to exit.
-        """
-        try:
-            self._popen.stdin.close()
-        except BlockingIOError:
-            # .close() will attempt to flush any buffered writes to stdout
-            # before the close returns. This may block, but since the file
-            # descriptor is non-blocking, we get a BlockingIOError.
-            pass
-        self._popen.stdout.close()
-        for _ in range(nice_timeout_seconds):
-            if self._popen.poll() is not None:
-                break
-            await asyncio.sleep(1)
-        self._popen.kill()
-        return_code = self._popen.returncode
-        return return_code if return_code is not None else -9
-
-    async def write(self, stdin_data: bytes, timeout_seconds: int):
-        """
-        Write data to the process's stdin.
-        """
-        if self._popen.poll() is not None:
-            return False
-
-        write_start_index = 0
-        start_time = time.time()
-        while write_start_index < len(stdin_data):
-            try:
-                bytes_written = self._popen.stdin.write(stdin_data[write_start_index:])
-                self._popen.stdin.flush()
-            except BlockingIOError as exn:
-                if exn.errno != errno.EAGAIN:
-                    return False
-                bytes_written = exn.characters_written
-                await asyncio.sleep(_SLEEP_AFTER_WOUND_BLOCK)
-            except BrokenPipeError:
-                # The child has closed stdin. It is likely dead.
-                return False
-            write_start_index += bytes_written
-            if time.time() - start_time > timeout_seconds:
-                return False
-        return True
-
-    def _read_line_from_saved_bytes(self, newline_search_index: int) -> Optional[bytes]:
-        """
-        Try to read a line of output from the buffer of stdout that this object
-        manages itself. The newline_search_index to indicate where to  start
-        looking for b"\n". Typically will be 0, but there are cases where we
-        are certain that the the newline is not in a prefix.
-        """
-        newline_index = self._stdout_saved_bytes.find(b"\n", newline_search_index)
-        if newline_index == -1:
-            return None
-        # memoryview helps avoid a pointless copy
-        line = memoryview(self._stdout_saved_bytes)[:newline_index].tobytes()
-        del self._stdout_saved_bytes[: newline_index + 1]
-        return line
-
-    async def read_line(self, timeout_seconds: int) -> Optional[bytes]:
-        """
-        Read a line from the process's stdout.
-        """
-        from_saved_bytes = self._read_line_from_saved_bytes(0)
-        if from_saved_bytes is not None:
-            return from_saved_bytes
-        if self._popen.poll() is not None:
-            return None
-        deadline = time.time() + timeout_seconds
-        while time.time() < deadline:
-            new_bytes = self._popen.stdout.read(_MAX_BYTES_PER_READ)
-            # If the read would block, we get None and not zero bytes on MacOS.
-            if new_bytes is None:
-                await asyncio.sleep(_SLEEP_AFTER_WOUND_BLOCK)
-                continue
-            # If we read 0 bytes, the child has closed stdout and is likely dead.
-            if len(new_bytes) == 0:
-                return None
-            prev_saved_bytes_len = len(self._stdout_saved_bytes)
-            self._stdout_saved_bytes.extend(new_bytes)
-            from_saved_bytes = self._read_line_from_saved_bytes(prev_saved_bytes_len)
-            if from_saved_bytes is not None:
-                return from_saved_bytes
-            if len(self._stdout_saved_bytes) > self._read_buffer_size:
-                del self._stdout_saved_bytes[
-                    : len(self._stdout_saved_bytes) - self._read_buffer_size
-                ]
-            await asyncio.sleep(_SLEEP_AFTER_WOUND_BLOCK)
-
-        return None