py-posix-shell 0.4.0__tar.gz → 0.4.2__tar.gz

{py_posix_shell-0.4.0 → py_posix_shell-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: py-posix-shell
-Version: 0.4.0
+Version: 0.4.2
 Summary: A cross-platform POSIX-style shell written in Python.
 Author: GGN_2015
 License-Expression: MIT

{py_posix_shell-0.4.0 → py_posix_shell-0.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "py-posix-shell"
-version = "0.4.0"
+version = "0.4.2"
 description = "A cross-platform POSIX-style shell written in Python."
 readme = "README.md"
 requires-python = ">=3.10"

{py_posix_shell-0.4.0 → py_posix_shell-0.4.2}/src/py_posix_shell/__init__.py

@@ -1,3 +1,3 @@
 """A cross-platform POSIX-style shell."""
 
-__version__ = "0.4.0"
+__version__ = "0.4.2"

{py_posix_shell-0.4.0 → py_posix_shell-0.4.2}/src/py_posix_shell/cli.py

@@ -35,6 +35,9 @@ def main(argv: list[str] | None = None) -> int:
             return shell.execute(args.command)
         except ShellExit as exc:
             return exc.status
+        except KeyboardInterrupt:
+            print(file=sys.stderr)
+            return 130
 
     if args.script:
         try:
@@ -48,13 +51,22 @@ def main(argv: list[str] | None = None) -> int:
             return shell.execute(source)
         except ShellExit as exc:
             return exc.status
+        except KeyboardInterrupt:
+            print(file=sys.stderr)
+            return 130
 
     interactive = args.interactive or sys.stdin.isatty()
     shell = Shell(argv0="pysh", interactive=interactive)
     if interactive:
-        return shell.repl()
+        try:
+            return shell.repl()
+        except KeyboardInterrupt:
+            print(file=sys.stderr)
+            return 130
     try:
         return shell.execute(sys.stdin.read())
     except ShellExit as exc:
         return exc.status
-
+    except KeyboardInterrupt:
+        print(file=sys.stderr)
+        return 130

{py_posix_shell-0.4.0 → py_posix_shell-0.4.2}/src/py_posix_shell/shell.py

@@ -6,6 +6,7 @@ import contextlib
 import fnmatch
 import io
 import os
+import signal
 import shlex
 import shutil
 import subprocess
@@ -141,6 +142,8 @@ class Shell:
         except ShellContinue:
             self.stderr.write(f"{self.argv0}: continue: only meaningful in a loop\n")
             status = 2
+        except KeyboardInterrupt:
+            status = 130
         except ShellExit as exc:
             self.last_status = exc.status
             if self._execute_depth == 1:
@@ -700,10 +703,10 @@ class Shell:
         communicate_input = input_text
 
         if input_text is not None:
-            popen_stdin = None
+            popen_stdin = subprocess.PIPE
         elif not has_fileno(stdin):
             communicate_input = stdin.read()
-            popen_stdin = None
+            popen_stdin = subprocess.PIPE
 
         stdout_capture_target: TextIO | None = None
         if capture_stdout:
@@ -718,34 +721,39 @@ class Shell:
             popen_stderr = subprocess.PIPE
 
         try:
-            completed = subprocess.run(
+            process = subprocess.Popen(
                 [executable, *argv[1:]],
-                input=communicate_input,
                 stdin=popen_stdin,
                 stdout=popen_stdout,
                 stderr=popen_stderr,
                 env=env,
                 text=True,
             )
+            completed_stdout, completed_stderr = process.communicate(input=communicate_input)
         except PermissionError:
             (stderr or self.stderr).write(f"{argv[0]}: permission denied\n")
             return 126
         except FileNotFoundError:
             (stderr or self.stderr).write(f"{argv[0]}: command not found\n")
             return 127
+        except KeyboardInterrupt:
+            if "process" in locals():
+                stop_process_after_interrupt(process)
+            self._last_external_output = ""
+            return 130
         except OSError as exc:
             (stderr or self.stderr).write(f"{argv[0]}: {exc}\n")
             return 126
 
-        if capture_stdout and completed.stdout:
-            self._last_external_output = completed.stdout
+        if capture_stdout and completed_stdout:
+            self._last_external_output = completed_stdout
         else:
             self._last_external_output = ""
-        if stdout_capture_target is not None and completed.stdout:
-            stdout_capture_target.write(completed.stdout)
-        if stderr_capture_target is not None and completed.stderr:
-            stderr_capture_target.write(completed.stderr)
-        return completed.returncode
+        if stdout_capture_target is not None and completed_stdout:
+            stdout_capture_target.write(completed_stdout)
+        if stderr_capture_target is not None and completed_stderr:
+            stderr_capture_target.write(completed_stderr)
+        return normalize_process_status(process.returncode)
 
     def run_preexpanded(self, argv: list[str], *, stdin: TextIO, stdout: TextIO, stderr: TextIO) -> int:
         if not argv:
@@ -836,6 +844,12 @@ class Shell:
             except EOFError:
                 self.stdout.write("\n")
                 return status
+            except KeyboardInterrupt:
+                self.stdout.write("\n")
+                buffer = ""
+                status = 130
+                self.last_status = status
+                continue
             candidate = buffer + line + "\n"
             try:
                 parse(candidate)
@@ -847,10 +861,20 @@ class Shell:
                 buffer = ""
                 status = 2
                 continue
+            except KeyboardInterrupt:
+                self.stdout.write("\n")
+                buffer = ""
+                status = 130
+                self.last_status = status
+                continue
             try:
                 status = self.execute(candidate)
             except ShellExit as exc:
                 return exc.status
+            except KeyboardInterrupt:
+                self.stdout.write("\n")
+                status = 130
+                self.last_status = status
             buffer = ""
 
     def get_parameter(self, name: str, *, strict: bool = False) -> str:
@@ -947,6 +971,46 @@ def has_fileno(stream: TextIO) -> bool:
     return True
 
 
+def stop_process_after_interrupt(process: subprocess.Popen[str]) -> None:
+    try:
+        process.wait(timeout=0.2)
+        return
+    except subprocess.TimeoutExpired:
+        pass
+    except OSError:
+        return
+
+    try:
+        if os.name == "nt":
+            process.terminate()
+        else:
+            process.send_signal(signal.SIGINT)
+    except OSError:
+        return
+
+    try:
+        process.wait(timeout=1)
+    except subprocess.TimeoutExpired:
+        try:
+            process.kill()
+        except OSError:
+            return
+        try:
+            process.wait(timeout=1)
+        except (OSError, subprocess.TimeoutExpired):
+            return
+    except OSError:
+        return
+
+
+def normalize_process_status(returncode: int) -> int:
+    if os.name == "nt" and returncode in {0xC000013A, -1073741510}:
+        return 130
+    if returncode < 0:
+        return 128 + abs(returncode)
+    return returncode
+
+
 def invert_status(status: int) -> int:
     return 0 if status != 0 else 1
 

{py_posix_shell-0.4.0 → py_posix_shell-0.4.2}/tests/test_shell.py

@@ -4,6 +4,7 @@ import io
 import os
 import sys
 
+import py_posix_shell.shell as shell_module
 from py_posix_shell.lexer import dump_tokens, lex
 from py_posix_shell.errors import ShellExit
 from py_posix_shell.shell import Shell
@@ -339,6 +340,60 @@ def test_command_and_type_report_internal_utility_when_path_is_empty():
     assert stderr == ""
 
 
+def test_external_keyboard_interrupt_returns_130(monkeypatch):
+    shell = Shell(stdin=io.StringIO(), stdout=io.StringIO(), stderr=io.StringIO())
+    shell.resolve_command = lambda _name, _env: "fake-more"  # type: ignore[method-assign]
+    events: list[str] = []
+
+    class FakeProcess:
+        returncode = None
+
+        def communicate(self, input=None):
+            events.append(f"communicate:{input!r}")
+            raise KeyboardInterrupt
+
+        def wait(self, timeout=None):
+            events.append(f"wait:{timeout}")
+            if timeout == 0.2:
+                raise shell_module.subprocess.TimeoutExpired("fake-more", timeout)
+            self.returncode = -2
+            return self.returncode
+
+        def terminate(self):
+            events.append("terminate")
+
+        def send_signal(self, sig):
+            events.append(f"signal:{sig}")
+
+        def kill(self):
+            events.append("kill")
+
+    monkeypatch.setattr(shell_module.subprocess, "Popen", lambda *args, **kwargs: FakeProcess())
+
+    assert shell.run_external(["more"]) == 130
+    assert "communicate:''" in events
+    assert "terminate" in events or any(event.startswith("signal:") for event in events)
+    assert shell.stderr.getvalue() == ""
+
+
+def test_repl_keyboard_interrupt_returns_to_prompt(monkeypatch):
+    stdout = io.StringIO()
+    shell = Shell(stdout=stdout, stderr=io.StringIO(), interactive=True)
+    events = iter([KeyboardInterrupt, "echo after:$?", EOFError])
+
+    def fake_input(_prompt):
+        event = next(events)
+        if isinstance(event, type) and issubclass(event, BaseException):
+            raise event
+        return event
+
+    monkeypatch.setattr("builtins.input", fake_input)
+
+    assert shell.repl() == 0
+    assert shell.last_status == 0
+    assert stdout.getvalue() == "\nafter:130\n\n"
+
+
 def test_internal_extended_text_utilities_without_path(tmp_path):
     data = tmp_path / "data.txt"
     csv = tmp_path / "data.csv"