bounded_subprocess 1.5.0__py3-none-any.whl → 2.1.0__py3-none-any.whl

bounded_subprocess/__init__.py

@@ -1,30 +1,34 @@
-import time
-from typing import List
+"""
+Bounded subprocess execution with timeout and output limits.
 
-from .util import Result, BoundedSubprocessState, SLEEP_BETWEEN_READS
+This package provides convenient functions for running subprocesses with bounded
+execution time and output size, with support for both synchronous and asynchronous
+execution patterns.
+"""
 
+__version__ = "1.0.0"
 
-def run(
-    args: List[str],
-    timeout_seconds: int = 15,
-    max_output_size: int = 2048,
-    env=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)
+# Lazy imports for better startup performance
+def __getattr__(name):
+    if name == "run":
+        from .bounded_subprocess import run
+        return run
+    elif name == "Result":
+        from .util import Result
+        return Result
+    elif name == "BoundedSubprocessState": 
+        from .util import BoundedSubprocessState
+        return BoundedSubprocessState
+    elif name == "SLEEP_BETWEEN_READS":
+        from .util import SLEEP_BETWEEN_READS
+        return SLEEP_BETWEEN_READS
+    else:
+        raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
 
-    # We sleep for 0.1 seconds in each iteration.
-    max_iterations = timeout_seconds * 10
-
-    for _ in range(max_iterations):
-        keep_reading = state.try_read()
-        if keep_reading:
-            time.sleep(SLEEP_BETWEEN_READS)
-        else:
-            break
-
-    return state.terminate()
+# Expose key classes and constants for convenience
+__all__ = [
+    "run",
+    "Result", 
+    "BoundedSubprocessState",
+    "SLEEP_BETWEEN_READS"
+]

bounded_subprocess/bounded_subprocess.py

@@ -0,0 +1,45 @@
+import time
+from typing import List, Optional
+
+from .util import (
+    Result,
+    BoundedSubprocessState,
+    SLEEP_BETWEEN_READS,
+    write_loop_sync,
+    _STDIN_WRITE_TIMEOUT,
+)
+
+
+def run(
+    args: List[str],
+    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, 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
+
+    for _ in range(max_iterations):
+        keep_reading = state.try_read()
+        if keep_reading:
+            time.sleep(SLEEP_BETWEEN_READS)
+        else:
+            break
+
+    return state.terminate()

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,
+        )
+        state.close_stdin()
 
     # 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/interactive.py

@@ -3,129 +3,122 @@ from typing import List, Optional
 import time
 import errno
 import subprocess
-from .util import set_nonblocking
+from .util import set_nonblocking, MAX_BYTES_PER_READ, write_loop_sync
 
-
-_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.
-        """
+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,
-            # stderr=subprocess.PIPE,
-            bufsize=_MAX_BYTES_PER_READ,
+            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
+        self.popen = popen
+        self.read_buffer_size = read_buffer_size
+        self.stdout_saved_bytes = bytearray()
 
-    def close(self, nice_timeout_seconds: int) -> int:
-        """
-        Close the process and wait for it to exit.
-        """
+    # --- low level helpers -------------------------------------------------
+    def poll(self) -> Optional[int]:
+        return self.popen.poll()
+
+    def close_pipes(self) -> None:
         try:
-            self._popen.stdin.close()
+            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
+        self.popen.stdout.close()
 
-        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)
+    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
-        # memoryview helps avoid a pointless copy
-        line = memoryview(self._stdout_saved_bytes)[:newline_index].tobytes()
-        del self._stdout_saved_bytes[: newline_index + 1]
+        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]:
-        """
-        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:
+        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._popen.stdout.read(_MAX_BYTES_PER_READ)
-            # If the read would block, we get None and not zero bytes on MacOS.
+            new_bytes = self._state.read_chunk()
             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
-                ]
+            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/interactive_async.py

@@ -1,131 +1,58 @@
 from typeguard import typechecked
 from typing import List, Optional
-import time
-import errno
-import subprocess
-from .util import set_nonblocking
 import asyncio
+import time
 
-_MAX_BYTES_PER_READ = 1024
-_SLEEP_AFTER_WOUND_BLOCK = 0.5
+from .interactive import _InteractiveState, _SLEEP_AFTER_WOUND_BLOCK
+from .util import write_loop_async
 
 
 @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.
-    """
+    """Asynchronous interface for interacting with a subprocess."""
 
-    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 __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:
-        """
-        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()
+    async def close(self, nice_timeout_seconds: int) -> int:
+        self._state.close_pipes()
         for _ in range(nice_timeout_seconds):
-            if self._popen.poll() is not None:
+            if self._state.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
+        self._state.kill()
+        return self._state.return_code()
 
-    async def write(self, stdin_data: bytes, timeout_seconds: int):
-        """
-        Write data to the process's stdin.
-        """
-        if self._popen.poll() is not None:
+    async def write(self, stdin_data: bytes, timeout_seconds: int) -> bool:
+        if self._state.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
+        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]:
-        """
-        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:
+        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._popen.stdout.read(_MAX_BYTES_PER_READ)
-            # If the read would block, we get None and not zero bytes on MacOS.
+            new_bytes = self._state.read_chunk()
             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
-                ]
+            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/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 = 1.0
 
 
 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,30 @@ 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
+
     def try_read(self) -> bool:
         """
         Reads from the process. Returning False indicates that we should stop

{bounded_subprocess-1.5.0.dist-info → bounded_subprocess-2.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bounded_subprocess
-Version: 1.5.0
+Version: 2.1.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.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+bounded_subprocess/__init__.py,sha256=L88cc8vG7GE11T0fF1-tMUIbRRlOmmlCqa6wopP3Ox8,1003
+bounded_subprocess/bounded_subprocess.py,sha256=-UuVhlbuMEWDNDjr_9tSUkcRxb-3RZKqOqup0nQI0zA,1231
+bounded_subprocess/bounded_subprocess_async.py,sha256=XSvi-FiKZbVbREnKDGiSG4UVViVoUBCCQzEohAS5GwM,1543
+bounded_subprocess/interactive.py,sha256=4fG4NB3eN5rqssUpfjiEQL2F-S7eDBwB2Mw1gzCL3Qk,4149
+bounded_subprocess/interactive_async.py,sha256=WKPA2XBnq_qMh5WijyoSOpg2iJcsYcQSXNGjv6IEEfA,1979
+bounded_subprocess/util.py,sha256=zaTl2LkhyOelRGotlgISkKy8cURQaTTNweTYoSchISA,6402
+bounded_subprocess-2.1.0.dist-info/METADATA,sha256=sxiscwiihS4QqFDVzXhgnwDfPdFBWunmX7N8KScypCw,2664
+bounded_subprocess-2.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+bounded_subprocess-2.1.0.dist-info/licenses/LICENSE.txt,sha256=UVerBV0_1vMFt8QkaXuVnZVSlOiKDiBSieK5MNLy4Ls,1086
+bounded_subprocess-2.1.0.dist-info/RECORD,,

bounded_subprocess-1.5.0.dist-info/RECORD

@@ -1,9 +0,0 @@
-bounded_subprocess/__init__.py,sha256=PHsdbPdGYopVQH_KG8vdpifyt8ZuCLd0h_JeMRCPNdI,855
-bounded_subprocess/bounded_subprocess_async.py,sha256=uvwMhB0OSJ91qJXVFlIzWfNQXQzw9I8WV7RdNzNWVDc,1158
-bounded_subprocess/interactive.py,sha256=Vn-002fH6rAekOwugGqdZUZ3O3x1wY-mLxApBtyC-DA,5016
-bounded_subprocess/interactive_async.py,sha256=igxFfeC7zdQxX34-pQRlTNgYIpSbVFgmGYCCvpwsMPw,5085
-bounded_subprocess/util.py,sha256=MBP34Juj-3JGJj6-XFzTaLhPZztQGk2tpONH8AvUX48,3638
-bounded_subprocess-1.5.0.dist-info/METADATA,sha256=FA0SjIq_lciG1NrdOXjF29tCXIKAuCFO2WyiAlkwkdI,2664
-bounded_subprocess-1.5.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-bounded_subprocess-1.5.0.dist-info/licenses/LICENSE.txt,sha256=UVerBV0_1vMFt8QkaXuVnZVSlOiKDiBSieK5MNLy4Ls,1086
-bounded_subprocess-1.5.0.dist-info/RECORD,,