bounded_subprocess 2.2.0__py3-none-any.whl → 2.3.1__py3-none-any.whl

bounded_subprocess/bounded_subprocess.py

@@ -7,6 +7,7 @@ from .util import (
     SLEEP_BETWEEN_READS,
     write_loop_sync,
     _STDIN_WRITE_TIMEOUT,
+    SLEEP_BETWEEN_WRITES,
 )
 
 
@@ -16,6 +17,7 @@ def run(
     max_output_size: int = 2048,
     env=None,
     stdin_data: Optional[str] = None,
+    stdin_write_timeout: Optional[int] = None,
 ) -> Result:
     """
     Runs the given program with arguments. After the timeout elapses, kills the process
@@ -24,12 +26,16 @@ def run(
     """
     state = BoundedSubprocessState(args, env, max_output_size, stdin_data is not None)
     if stdin_data is not None:
-        write_loop_sync(
+        ok = write_loop_sync(
             state.write_chunk,
             stdin_data.encode(),
-            _STDIN_WRITE_TIMEOUT,
-            sleep_interval=SLEEP_BETWEEN_READS,
+            stdin_write_timeout if stdin_write_timeout is not None else 15,
+            sleep_interval=SLEEP_BETWEEN_WRITES,
         )
+        if not ok:
+            state.terminate()
+            return Result(True, -1, "", "failed to write to stdin")
+
         state.close_stdin()
 
     # We sleep for 0.1 seconds in each iteration.

bounded_subprocess/bounded_subprocess_async.py

@@ -4,7 +4,7 @@ from .util import (
     Result,
     BoundedSubprocessState,
     SLEEP_BETWEEN_READS,
-    write_loop_async,
+    write_nonblocking_async,
     _STDIN_WRITE_TIMEOUT,
 )
 
@@ -15,6 +15,7 @@ async def run(
     max_output_size: int = 2048,
     env=None,
     stdin_data: Optional[str] = None,
+    stdin_write_timeout: Optional[int] = None,
 ) -> Result:
     """
     Runs the given program with arguments. After the timeout elapses, kills the process
@@ -27,14 +28,16 @@ async def run(
     # async here? It's just the sleep between reads.
     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,
+        write_ok = await write_nonblocking_async(
+            fd=state.p.stdin,
+            data=stdin_data.encode(),
+            timeout_seconds=stdin_write_timeout if stdin_write_timeout is not None else 15,
         )
         await state.close_stdin_async(_STDIN_WRITE_TIMEOUT)
 
+    # Notice that we do not immediately terminate if the write fails. This allows
+    # us to read an error message from the process.
+
     # We sleep for 0.1 seconds in each iteration.
     max_iterations = timeout_seconds * 10
 
@@ -45,5 +48,9 @@ async def run(
         else:
             break
 
-    return state.terminate()
+    result = state.terminate()
+    if stdin_data is not None and not write_ok:
+        result.exit_code = -1
+        result.stderr = result.stderr + "\nFailed to write all data to subprocess."
+    return result
 

bounded_subprocess/util.py

@@ -9,7 +9,8 @@ import asyncio
 
 MAX_BYTES_PER_READ = 1024
 SLEEP_BETWEEN_READS = 0.1
-_STDIN_WRITE_TIMEOUT = 3
+_STDIN_WRITE_TIMEOUT = 15
+SLEEP_BETWEEN_WRITES = 0.01
 
 
 class Result:
@@ -93,6 +94,59 @@ async def write_loop_async(
     return True
 
 
+async def can_write(fd):
+    """
+    Waits for the file descriptor to be writable.
+    """
+    future = asyncio.Future()
+    loop  = asyncio.get_running_loop()
+    loop.add_writer(fd, future.set_result, None)
+    future.add_done_callback(lambda f: loop.remove_writer(fd))
+    await future
+
+
+async def write_nonblocking_async(*, fd, data: bytes, timeout_seconds: int) -> bool:
+    """
+    Writes to a nonblocking file descriptor with the timeout.
+
+    Returns True if all the data was written. False indicates that there was
+    either a timeout or a broken pipe.
+    """
+    start_time_seconds = time.time()
+
+    # A slice, data[..], would create a copy. A memoryview does not.
+    mv = memoryview(data)
+    start = 0
+    while start < len(mv):
+        try:
+            # Write as much as possible without blocking.
+            written = fd.write(mv[start:])
+            if written is None:
+                written = 0
+            start = start + written
+        except BrokenPipeError:
+            return False
+        except BlockingIOError as exn:
+            if exn.errno != errno.EAGAIN:
+                # NOTE(arjun): I am not certain why this would happen. However,
+                # you are only supposed to retry on EAGAIN.
+                return False
+            # Some, but not all the bytes were written.
+            start = start + exn.characters_written
+            
+            # Compute how much more time we have left.
+            wait_timeout = timeout_seconds - (time.time() - start_time_seconds)
+            # We are already past the deadline, so abort.
+            if wait_timeout <= 0:
+                return False
+            try:
+                await asyncio.wait_for(can_write(fd), wait_timeout)
+            except asyncio.TimeoutError:
+                # Deadline elapsed, so abort.
+                return False
+
+    return True
+
 class BoundedSubprocessState:
     """State shared between synchronous and asynchronous subprocess helpers."""
 

{bounded_subprocess-2.2.0.dist-info → bounded_subprocess-2.3.1.dist-info}/METADATA

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

@@ -0,0 +1,10 @@
+bounded_subprocess/__init__.py,sha256=L88cc8vG7GE11T0fF1-tMUIbRRlOmmlCqa6wopP3Ox8,1003
+bounded_subprocess/bounded_subprocess.py,sha256=BkGDiPKuyl3Mftn6kUkdUbIfeXuLCYWDo57T1uAa-hI,1470
+bounded_subprocess/bounded_subprocess_async.py,sha256=3QJ6GC3-ZD4-CWeHB13bOAtBrz6a955hwcZc6BRn2Os,1978
+bounded_subprocess/interactive.py,sha256=4fG4NB3eN5rqssUpfjiEQL2F-S7eDBwB2Mw1gzCL3Qk,4149
+bounded_subprocess/interactive_async.py,sha256=WKPA2XBnq_qMh5WijyoSOpg2iJcsYcQSXNGjv6IEEfA,1979
+bounded_subprocess/util.py,sha256=we97jCA6kfHBfDu88hFKutUpyk_qg0Y363-_ScVhN8Y,8646
+bounded_subprocess-2.3.1.dist-info/METADATA,sha256=iXgj3YNE1iLLw8E1-DS2mciLmTJUaVnGAjjQHSutRYM,2664
+bounded_subprocess-2.3.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+bounded_subprocess-2.3.1.dist-info/licenses/LICENSE.txt,sha256=UVerBV0_1vMFt8QkaXuVnZVSlOiKDiBSieK5MNLy4Ls,1086
+bounded_subprocess-2.3.1.dist-info/RECORD,,

bounded_subprocess-2.2.0.dist-info/RECORD

@@ -1,10 +0,0 @@
-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=Rp6EMURNL8D5-zyEfPfW93GsResWAykla-W80bjE0eQ,1575
-bounded_subprocess/interactive.py,sha256=4fG4NB3eN5rqssUpfjiEQL2F-S7eDBwB2Mw1gzCL3Qk,4149
-bounded_subprocess/interactive_async.py,sha256=WKPA2XBnq_qMh5WijyoSOpg2iJcsYcQSXNGjv6IEEfA,1979
-bounded_subprocess/util.py,sha256=OLIfD3r_Kf2LZzMU98HGeLHh3TdVgwoAO1GEMpEx4DQ,6760
-bounded_subprocess-2.2.0.dist-info/METADATA,sha256=ELBEH4eszwiufzd5dKRCblGEaebB-qLlhJWoU9gQyrM,2664
-bounded_subprocess-2.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-bounded_subprocess-2.2.0.dist-info/licenses/LICENSE.txt,sha256=UVerBV0_1vMFt8QkaXuVnZVSlOiKDiBSieK5MNLy4Ls,1086
-bounded_subprocess-2.2.0.dist-info/RECORD,,