Only sleep when input stream is waiting

This change means that we don't delay reading the input stream when
there is still data available to read from it.

This provides a significant speed improvement to scripts which are
passing a populated stream of data, rather than awaiting user input from
stdin.

See #774

Author: meshy

invoke/runners.py

@@ -912,8 +912,10 @@ def handle_stdin(
                 # race conditions re: unread stdin.)
                 if self.program_finished.is_set() and not data:
                     break
+                # When data is None, we're waiting for input on stdin.
                 # Take a nap so we're not chewing CPU.
-                time.sleep(self.input_sleep)
+                if data is None:
+                    time.sleep(self.input_sleep)
 
     def should_echo_stdin(self, input_: IO, output: IO) -> bool:
         """

tests/runners.py

@@ -7,7 +7,7 @@
 import threading
 import types
 from contextlib import AbstractContextManager
-from io import BytesIO, StringIO
+from io import BytesIO, StringIO, TextIOBase
 from itertools import chain, repeat
 from unittest.mock import Mock, call, patch
 
@@ -1100,16 +1100,52 @@ def subclasses_can_override_input_sleep(self):
             class MyRunner(_Dummy):
                 input_sleep = 0.007
 
+            def fake_stdin_stream():
+                # The value "foo" is eventually returned.
+                yield "f"
+                # None values simulate waiting for input on stdin.
+                yield None
+                yield "o"
+                yield None
+                yield "o"
+                yield None
+                # Once the stream is closed, stdin returns empty strings.
+                while True:
+                    yield ""
+
+            class FakeStdin(TextIOBase):
+                def __init__(self, stdin):
+                    self.stream = stdin
+
+                def read(self, size):
+                    return next(self.stream)
+
             with patch("invoke.runners.time") as mock_time:
                 MyRunner(Context()).run(
                     _,
-                    in_stream=StringIO("foo"),
+                    in_stream=FakeStdin(fake_stdin_stream()),
                     out_stream=StringIO(),  # null output to not pollute tests
                 )
-            # Just make sure the first few sleeps all look good. Can't know
-            # exact length of list due to stdin worker hanging out til end of
-            # process. Still worth testing more than the first tho.
-            assert mock_time.sleep.call_args_list[:3] == [call(0.007)] * 3
+            # Just make sure the sleeps all look good.
+            # There are three calls because of the Nones in fake_stdin_stream.
+            assert mock_time.sleep.call_args_list == [call(0.007)] * 3
+
+        @mock_subprocess()
+        def populated_streams_do_not_sleep(self):
+            class MyRunner(_Dummy):
+                read_chunk_size = 1
+
+            runner = MyRunner(Context())
+            with patch("invoke.runners.time") as mock_time:
+                with patch.object(runner, "wait"):
+                    runner.run(
+                        _,
+                        in_stream=StringIO("lots of bytes to read"),
+                        # null output to not pollute tests
+                        out_stream=StringIO(),
+                    )
+            # Sleep should not be called before we break.
+            assert len(mock_time.sleep.call_args_list) == 0
 
     class stdin_mirroring:
         def _test_mirroring(self, expect_mirroring, **kwargs):