pyallel 2.0.6__tar.gz → 2.1.0__tar.gz

{pyallel-2.0.6 → pyallel-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyallel
-Version: 2.0.6
+Version: 2.1.0
 Summary: Run and handle the output of multiple executables in pyallel (as in parallel)
 Project-URL: Homepage, https://github.com/Danthewaann/pyallel
 Project-URL: Repository, https://github.com/Danthewaann/pyallel
@@ -39,7 +39,7 @@ pipx install pyallel
 Once installed, you can run `pyallel` to see usage information, like so:
 
 ```
-usage: pyallel [-h] [-t] [-n] [-V] [--colour {yes,no,auto}] [commands ...]
+usage: pyallel [-h] [-t] [-n] [-V] [--colour {yes,no,auto}] [--debug] [commands ...]
 
 run and handle the output of multiple executables in pyallel (as in parallel)
 
@@ -98,6 +98,7 @@ options:
   -V, --version         print version and exit
   --colour {yes,no,auto}
                         colour terminal output, defaults to "auto"
+  --debug               enable debug mode, which logs debug info to a "pyallel.log" file in the current directory
 ```
 
 Currently you can provide a variable number of `commands` to run to `pyallel`, like so:
@@ -158,7 +159,7 @@ pipx install uv && \
       before a given command can start)
 - [x] Add support to state how many lines a command can use for it's output in interactive mode
 - [x] Improve printing of output performance by only printing lines that have changed
-- [ ] Add a debug mode that logs debug information to a log file
+- [x] Add a debug mode that logs debug information to a log file
 - [ ] Maybe add support to allow the user to provide stdin for commands that request it
       (such as a REPL)
 - [ ] Add custom parsing of command output to support filtering for errors (like vim's

{pyallel-2.0.6 → pyallel-2.1.0}/README.md

@@ -21,7 +21,7 @@ pipx install pyallel
 Once installed, you can run `pyallel` to see usage information, like so:
 
 ```
-usage: pyallel [-h] [-t] [-n] [-V] [--colour {yes,no,auto}] [commands ...]
+usage: pyallel [-h] [-t] [-n] [-V] [--colour {yes,no,auto}] [--debug] [commands ...]
 
 run and handle the output of multiple executables in pyallel (as in parallel)
 
@@ -80,6 +80,7 @@ options:
   -V, --version         print version and exit
   --colour {yes,no,auto}
                         colour terminal output, defaults to "auto"
+  --debug               enable debug mode, which logs debug info to a "pyallel.log" file in the current directory
 ```
 
 Currently you can provide a variable number of `commands` to run to `pyallel`, like so:
@@ -140,7 +141,7 @@ pipx install uv && \
       before a given command can start)
 - [x] Add support to state how many lines a command can use for it's output in interactive mode
 - [x] Improve printing of output performance by only printing lines that have changed
-- [ ] Add a debug mode that logs debug information to a log file
+- [x] Add a debug mode that logs debug information to a log file
 - [ ] Maybe add support to allow the user to provide stdin for commands that request it
       (such as a REPL)
 - [ ] Add custom parsing of command output to support filtering for errors (like vim's

{pyallel-2.0.6 → pyallel-2.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pyallel"
-version = "2.0.6"
+version = "2.1.0"
 description = "Run and handle the output of multiple executables in pyallel (as in parallel)"
 authors = [{ name = "Daniel Black", email = "danielcrblack@gmail.com" }]
 requires-python = ">=3.8"

pyallel-2.1.0/src/pyallel/logging.py

@@ -0,0 +1,14 @@
+import logging
+import os
+
+
+def configure_logging(*, debug: bool = False) -> None:
+    if debug:
+        logging.basicConfig(
+            filename="pyallel.log",
+            format="%(asctime)s:%(name)s:%(lineno)d:%(message)s",
+            datefmt="%Y-%m-%dT%H:%M:%S",
+            level=logging.DEBUG,
+        )
+    else:
+        logging.basicConfig(handlers=[logging.StreamHandler(stream=open(os.devnull, "w"))])  # noqa: PTH123, SIM115

{pyallel-2.0.6 → pyallel-2.1.0}/src/pyallel/main.py

@@ -9,6 +9,7 @@ import traceback
 from pyallel import constants
 from pyallel.colours import Colours
 from pyallel.errors import PyallelError
+from pyallel.logging import configure_logging
 from pyallel.parser import Arguments, create_parser
 from pyallel.printer import (
     InteractiveConsolePrinter,
@@ -17,13 +18,6 @@ from pyallel.printer import (
 )
 from pyallel.process_group_manager import ProcessGroupManager
 
-logging.basicConfig(
-    filename="pyallel.log",
-    format="%(asctime)s:%(levelname)s:%(name)s:%(lineno)d[%(threadName)s]:%(message)s",
-    datefmt="%Y-%m-%dT%H:%M:%S",
-    level=logging.DEBUG,
-)
-
 logger = logging.getLogger(__name__)
 
 
@@ -41,6 +35,8 @@ def entry_point(*args: str) -> int:
         parser.print_help()
         return 2
 
+    configure_logging(debug=parsed_args.debug)
+
     colours = Colours.from_colour(parsed_args.colour)
     printer: Printer
     if not parsed_args.interactive or not constants.IN_TTY:
@@ -54,19 +50,24 @@ def entry_point(*args: str) -> int:
         print(f"{colours.red_bold}Error: {e!s}{colours.reset_colour}")
         return 1
 
+    logger.debug("starting run with arguments:\n%s", parsed_args)
     try:
         exit_code = run(process_group_manager, printer)
     except Exception:
+        logger.exception("failed run with arguments:\n%s", parsed_args)
         print(f"{colours.red_bold}Error: {traceback.format_exc()}{colours.reset_colour}")
         return 1
 
     if exit_code == 1:
+        logger.error("failed run with arguments:\n%s", parsed_args)
         process_group = process_group_manager.get_cur_process_group_output()
         print(f"\n{colours.red_bold}ERROR: the following commands failed{colours.reset_colour}")
         for process_output in process_group.processes:
             process_poll = process_output.process.poll()
             if process_poll and process_poll > 0:
                 print(f"   {colours.red_bold}{process_output.process.command}{colours.reset_colour}")
+    else:
+        logger.debug("finished run with arguments:\n%s", parsed_args)
 
     return exit_code
 
@@ -81,8 +82,7 @@ def run(process_group_manager: ProcessGroupManager, printer: Printer) -> int:
         if poll is not None:
             # If we still have new output to print after the process group manager has completed,
             # make sure to print it here before continuing
-            has_output = process_group_manager.stream().has_output()
-            if has_output:
+            if process_group_manager.stream().has_output():
                 printer.print(process_group_manager)
 
             if poll > 0:

{pyallel-2.0.6 → pyallel-2.1.0}/src/pyallel/parser.py

@@ -10,13 +10,16 @@ class Arguments:
     interactive: bool
     timer: bool
     version: bool
+    debug: bool
 
     def __repr__(self) -> str:
-        msg = "Arguments:\n"
+        msg = ""
         padding = len(sorted(self.__dict__.keys(), key=len, reverse=True)[0]) + 1
         for field, value in self.__dict__.items():
-            msg += f"    {field: <{padding}}: {value}\n"
-        return msg
+            if field == "commands":
+                value = " ".join(value)  # noqa: PLW2901
+            msg += f"{field: <{padding}}: {value}\n"
+        return msg.strip()
 
 
 DESCRIPTION = r"""run and handle the output of multiple executables in %(prog)s (as in parallel)
@@ -108,5 +111,11 @@ def create_parser() -> ArgumentParser:
         choices=("yes", "no", "auto"),
         default="auto",
     )
+    parser.add_argument(
+        "--debug",
+        help='enable debug mode, which logs debug info to a "pyallel.log" file in the current directory',
+        action="store_true",
+        default=False,
+    )
 
     return parser

{pyallel-2.0.6 → pyallel-2.1.0}/src/pyallel/printer.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import logging
 import time
 from typing import TYPE_CHECKING, Protocol
 
@@ -12,6 +13,9 @@ if TYPE_CHECKING:
     from pyallel.process_group_manager import ProcessGroupManager
 
 
+logger = logging.getLogger(__name__)
+
+
 class Printer(Protocol):
     def print(self, process_group_manager: ProcessGroupManager) -> None:
         """Print output obtained from the provided process group manager.
@@ -195,7 +199,7 @@ class ConsolePrinter:
 
         return self._to_print
 
-    def set_process_lines(
+    def set_process_lines(  # noqa: PLR0915
         self,
         output: ProcessGroupOutput,
         interrupt_count: int = 0,
@@ -205,8 +209,10 @@ class ConsolePrinter:
         if interrupt_count:
             lines -= 2
 
+        logger.debug("initial available lines in screen = %d", lines)
         # Allocate lines to processes that have a fixed percentage of lines set
         allocated_process_lines = lines // len(output.processes)
+        logger.debug("initial allocated_process_lines = %d", allocated_process_lines)
         processes_with_dynamic_lines: list[ProcessOutput] = []
         used_lines = 0
         for process_output in output.processes:
@@ -220,6 +226,7 @@ class ConsolePrinter:
 
         # Remove the used lines from the total available lines
         lines -= used_lines
+        logger.debug("available lines after allocating percentage lines = %d", lines)
 
         while lines:
             # Calculate how many lines each process should have based on how many processes and lines are left
@@ -231,9 +238,21 @@ class ConsolePrinter:
                 # If the number of lines in this process output is less than how many terminal lines we would allocate it,
                 # Set it's allocated terminal lines to the exact number of lines in its output and remove this number from
                 # the total available terminal lines
+                logger.debug(
+                    "process [%s] lines = %d, allocated = %d",
+                    process_output.process.command,
+                    process_output.lines,
+                    allocated_process_lines,
+                )
                 if process_output.lines < allocated_process_lines:
+                    logger.debug(
+                        "process [%s] lines less than allocated, reducing allocated lines to %s",
+                        process_output.process.command,
+                        process_output.lines,
+                    )
                     process_output.process.lines = process_output.lines
                     lines -= process_output.process.lines
+                    logger.debug("new available screen lines = %d", lines)
                     recalculate_lines = True
                     continue
 
@@ -243,17 +262,23 @@ class ConsolePrinter:
             # contains less lines than what we would normally allocate it. This is done so we can allocate these extra lines to the
             # other processes that contain more lines of output.
             if recalculate_lines:
+                logger.debug("recalcuting available screen lines")
                 processes_with_dynamic_lines = processes_with_excess_output
             else:
                 # All remaining processes exceed the number of terminal lines we will allocate them, so allocate them
                 # their terminal lines as normal and break out of the while loop
                 for process_output in processes_with_excess_output:
+                    logger.debug(
+                        "allocating %d lines to process [%s]", allocated_process_lines, process_output.process.command
+                    )
                     process_output.process.lines = allocated_process_lines
                     lines -= allocated_process_lines
+                    logger.debug("new available screen lines = %d", lines)
 
                 # If there is any lines left, allocate them to the process that currently contains the most lines in its output, or
                 # allocate them to the first process if no process contains enough lines
                 if lines:
+                    logger.debug("remaining lines after allocation to all processes = %d", lines)
                     process_with_most_lines: ProcessOutput | None = None
                     most_lines = 0
                     for process_output in output.processes:
@@ -262,12 +287,26 @@ class ConsolePrinter:
                             most_lines = process_output.process.lines
 
                     if not process_with_most_lines:
-                        output.processes[0].process.lines += lines
+                        logger.debug(
+                            "no process found with most output, allocating remaining lines to first process [%s]",
+                            process_output.process.command,
+                        )
+                        process = output.processes[0].process
+                        process.lines += lines
+                        logger.debug("process [%s] allocated lines = %d", process.command, process.lines)
                     else:
-                        process_with_most_lines.process.lines += lines
+                        logger.debug(
+                            "found process [%s] with most output, allocating remaining lines",
+                            process_output.process.command,
+                        )
+                        process = process_with_most_lines.process
+                        process.lines += lines
+                        logger.debug("process [%s] allocated lines = %d", process.command, process.lines)
 
                 break
 
+        logger.debug("all screen lines have been allocated")
+
     def get_num_lines(self, line: str, columns: int | None = None) -> int:
         lines = 0
         columns = columns or constants.columns()

{pyallel-2.0.6 → pyallel-2.1.0}/src/pyallel/process.py

@@ -72,20 +72,6 @@ class Process:
 
         return buffer
 
-    def readline(self) -> bytes:
-        with self._lock:
-            buffer = self._buffer
-            if not buffer:
-                return b""
-
-            newline_index = buffer.find(b"\n")
-            if newline_index == -1:
-                self._buffer = b""
-                return buffer
-
-            self._buffer = buffer[newline_index + 1 :]
-            return buffer[: newline_index + 1]
-
     def return_code(self) -> int | None:
         return self._process.returncode
 

{pyallel-2.0.6 → pyallel-2.1.0}/src/pyallel/process_group_manager.py

@@ -108,8 +108,8 @@ class ProcessGroupManager:
         return poll
 
     def handle_signal(self, signum: int, _frame: Any) -> None:
-        for process_group in self._process_groups:
-            process_group.handle_signal(signum)
+        if self._cur_process_group is not None:
+            self._cur_process_group.handle_signal(signum)
 
         self._exit_code = 128 + signum
         self._interrupt_count += 1

pyallel-2.1.0/tests/conftest.py

@@ -0,0 +1,13 @@
+import signal
+from typing import Generator
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+
+@pytest.fixture(autouse=True)
+def mock_signal() -> Generator[MagicMock]:
+    # Make sure we mock the signal module so interrupts work normally when running
+    # the test suite via pytest
+    with patch.object(signal, "signal") as mock:
+        yield mock

{pyallel-2.0.6 → pyallel-2.1.0}/tests/test_main.py

@@ -1,9 +1,5 @@
 import difflib
-import os
 import re
-import signal
-import subprocess
-import time
 from typing import Sequence
 
 import pytest
@@ -135,42 +131,6 @@ class TestInteractiveMode:
             ],
         )
 
-    @pytest.mark.parametrize(("signal", "exit_code"), [(signal.SIGINT, 130), (signal.SIGTERM, 143)])
-    def test_handles_multiple_signals(self, signal: int, exit_code: int) -> None:
-        process = subprocess.Popen(
-            [
-                "pyallel",
-                "./tests/assets/test_handle_multiple_signals.sh",
-            ],
-            env=os.environ.copy(),
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT,
-        )
-        time.sleep(0.3)
-        process.send_signal(signal)
-        time.sleep(0.1)
-        process.send_signal(signal)
-        assert process.wait() == exit_code
-
-    @pytest.mark.parametrize(("signal", "exit_code"), [(signal.SIGINT, 130), (signal.SIGTERM, 143)])
-    def test_handles_multiple_signals_with_dependant_commands(self, signal: int, exit_code: int) -> None:
-        process = subprocess.Popen(
-            [
-                "pyallel",
-                "./tests/assets/test_handle_multiple_signals.sh",
-                ":::",
-                "./tests/assets/test_handle_multiple_signals.sh",
-            ],
-            env=os.environ.copy(),
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT,
-        )
-        time.sleep(0.3)
-        process.send_signal(signal)
-        time.sleep(0.1)
-        process.send_signal(signal)
-        assert process.wait() == exit_code
-
 
 class TestNonInteractiveMode:
     def test_run_single_command(self, capsys: pytest.CaptureFixture[str]) -> None:
@@ -409,51 +369,3 @@ class TestNonInteractiveMode:
                 f"[printf hi; sleep {wait}; echo bye] done ✔",
             ],
         )
-
-    @pytest.mark.parametrize(("signal", "exit_code"), [(signal.SIGINT, 130), (signal.SIGTERM, 143)])
-    def test_handles_multiple_signals(self, signal: int, exit_code: int) -> None:
-        process = subprocess.Popen(
-            [
-                "pyallel",
-                "./tests/assets/test_handle_multiple_signals.sh",
-                "-n",
-                "-t",
-                "--colour",
-                "no",
-            ],
-            env=os.environ.copy(),
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT,
-        )
-        time.sleep(0.3)
-        process.send_signal(signal)
-        time.sleep(0.1)
-        process.send_signal(signal)
-        assert process.stdout is not None
-        out = process.stdout.read()
-        assert process.wait() == exit_code, prettify_error(out.decode())
-
-    @pytest.mark.parametrize(("signal", "exit_code"), [(signal.SIGINT, 130), (signal.SIGTERM, 143)])
-    def test_handles_multiple_signals_with_dependant_commands(self, signal: int, exit_code: int) -> None:
-        process = subprocess.Popen(
-            [
-                "pyallel",
-                "./tests/assets/test_handle_multiple_signals.sh",
-                ":::",
-                "./tests/assets/test_handle_multiple_signals.sh",
-                "-n",
-                "-t",
-                "--colour",
-                "no",
-            ],
-            env=os.environ.copy(),
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT,
-        )
-        time.sleep(0.3)
-        process.send_signal(signal)
-        time.sleep(0.1)
-        process.send_signal(signal)
-        assert process.stdout is not None
-        out = process.stdout.read()
-        assert process.wait() == exit_code, prettify_error(out.decode())

{pyallel-2.0.6 → pyallel-2.1.0}/tests/test_process.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
-import time
+import subprocess
+from unittest.mock import MagicMock, patch
 
 import pytest
 
@@ -58,42 +59,10 @@ def test_from_command_with_lines_modifier_handles_multiple_separators() -> None:
     assert process.percentage_lines == 0.5
 
 
-def test_read() -> None:
+@patch.object(subprocess, "Popen")
+def test_read(popen_mock: MagicMock) -> None:
+    popen_mock.return_value.stdout.read1.side_effect = [b"first\nsecond\n", b""]
     process = Process(1, "echo first; echo second")
     process.run()
-    time.sleep(0.01)
     output = process.read()
     assert output == b"first\nsecond\n"
-
-
-def test_readline() -> None:
-    process = Process(1, "echo first; echo second")
-    process.run()
-    time.sleep(0.01)
-    output = process.readline()
-    assert output == b"first\n"
-    output = process.readline()
-    assert output == b"second\n"
-
-
-def test_readline_with_read() -> None:
-    process = Process(1, "echo first; echo second")
-    process.run()
-    output = process.readline()
-    assert output == b""
-    time.sleep(0.01)
-    output = process.readline()
-    assert output == b"first\n"
-    output = process.read()
-    assert output == b"second\n"
-
-
-def test_readline_handles_delayed_newline() -> None:
-    process = Process(1, "printf first; sleep 0.1; echo second")
-    process.run()
-    time.sleep(0.01)
-    output = process.readline()
-    assert output == b"first"
-    time.sleep(0.3)
-    output = process.readline()
-    assert output == b"second\n"

{pyallel-2.0.6 → pyallel-2.1.0}/tests/test_process_group.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
-import time
+import subprocess
+from unittest.mock import MagicMock, patch
 
 import pytest
 
@@ -64,7 +65,9 @@ def test_from_commands_with_lines_modifier_exceeds_100() -> None:
         )
 
 
-def test_stream() -> None:
+@patch.object(subprocess, "Popen")
+def test_stream(popen_mock: MagicMock) -> None:
+    popen_mock.return_value.stdout.read1.return_value = b""
     process_group = ProcessGroup(
         id=1,
         processes=[
@@ -74,7 +77,6 @@ def test_stream() -> None:
         ],
     )
     process_group.run()
-    time.sleep(0.1)
     output = process_group.stream()
     assert len(output.processes) == 3
 

{pyallel-2.0.6 → pyallel-2.1.0}/tests/test_process_manager.py

@@ -1,6 +1,9 @@
 from __future__ import annotations
 
+import signal
+import subprocess
 import time
+from unittest.mock import MagicMock, call, patch
 
 import pytest
 
@@ -10,7 +13,10 @@ from pyallel.process_group import ProcessGroup
 from pyallel.process_group_manager import ProcessGroupManager
 
 
-def test_stream() -> None:
+@patch.object(subprocess, "Popen")
+def test_stream(popen_mock: MagicMock) -> None:
+    popen_mock.return_value.stdout.read1.return_value = b""
+    popen_mock.return_value.poll.return_value = 0
     pg_manager = ProcessGroupManager(
         process_groups=[
             ProcessGroup(
@@ -31,7 +37,6 @@ def test_stream() -> None:
     )
     pg_manager.run()
     pg_manager.get_cur_process_group_output()
-    time.sleep(0.1)
     output = pg_manager.stream()
     assert len(output.process_group_outputs) == 1
     assert output.process_group_outputs[1].id == 1
@@ -39,7 +44,6 @@ def test_stream() -> None:
     assert pg_manager.poll() == 0
     pg_manager.run()
     pg_manager.get_cur_process_group_output()
-    time.sleep(0.1)
     output = pg_manager.stream()
     assert len(output.process_group_outputs) == 1
     assert output.process_group_outputs[2].id == 2
@@ -47,8 +51,8 @@ def test_stream() -> None:
     assert pg_manager.poll() == 0
 
 
-def test_from_args() -> None:
-    expected_process_group_manager = ProcessGroupManager(
+def test_from_args(mock_signal: MagicMock) -> None:
+    expected_pg_manager = ProcessGroupManager(
         process_groups=[
             ProcessGroup(
                 id=1,
@@ -59,18 +63,26 @@ def test_from_args() -> None:
             )
         ]
     )
-    process_group_manager = ProcessGroupManager.from_args("sleep 0.1", "::", "sleep 0.2")
-    assert len(process_group_manager._process_groups) == len(expected_process_group_manager._process_groups)
+    pg_manager = ProcessGroupManager.from_args("sleep 0.1", "::", "sleep 0.2")
+    assert len(pg_manager._process_groups) == len(expected_pg_manager._process_groups)
 
     for pg1, pg2 in zip(
-        expected_process_group_manager._process_groups,
-        process_group_manager._process_groups,
+        expected_pg_manager._process_groups,
+        pg_manager._process_groups,
     ):
         assert len(pg1.processes) == len(pg2.processes)
 
+    assert mock_signal.call_count == 2
+    mock_signal.assert_has_calls(
+        [
+            call(signal.SIGINT, pg_manager.handle_signal),
+            call(signal.SIGTERM, pg_manager.handle_signal),
+        ]
+    )
+
 
 @pytest.mark.parametrize(
-    ("args", "expected_process_group_manager"),
+    ("args", "expected_pg_manager"),
     [
         (
             ["sleep 0.1", ":::", "sleep 0.2", "::", "sleep 0.3", ":::", "sleep 0.4"],
@@ -171,13 +183,13 @@ def test_from_args() -> None:
         ),
     ],
 )
-def test_from_args_with_separators(args: list[str], expected_process_group_manager: ProcessGroupManager) -> None:
-    process_group_manager = ProcessGroupManager.from_args(*args)
-    assert len(process_group_manager._process_groups) == len(expected_process_group_manager._process_groups)
+def test_from_args_with_separators(args: list[str], expected_pg_manager: ProcessGroupManager) -> None:
+    pg_manager = ProcessGroupManager.from_args(*args)
+    assert len(pg_manager._process_groups) == len(expected_pg_manager._process_groups)
 
     for pg1, pg2 in zip(
-        expected_process_group_manager._process_groups,
-        process_group_manager._process_groups,
+        expected_pg_manager._process_groups,
+        pg_manager._process_groups,
     ):
         assert len(pg1.processes) == len(pg2.processes)
 
@@ -188,3 +200,37 @@ def test_from_args_with_bad_separator() -> None:
         match=r"no commands provided for process group 1, did you forgot to provide them before the ::: symbol?",
     ):
         ProcessGroupManager.from_args(":::", "echo hi")
+
+
+@patch.object(subprocess, "Popen")
+def test_handle_signal(popen_mock: MagicMock) -> None:
+    popen_mock.return_value.stdout.read1.side_effect = lambda _: time.sleep(1)
+    pg_manager = ProcessGroupManager.from_args("sleep 0.1", "::", "sleep 0.2")
+    pg_manager.run()
+
+    pg_manager.handle_signal(signum=signal.SIGINT, _frame=MagicMock())
+
+    send_signal_mock: MagicMock = popen_mock.return_value.send_signal
+    assert send_signal_mock.call_count == 2
+    send_signal_mock.assert_has_calls([call(signal.SIGINT), call(signal.SIGINT)])
+
+
+@patch.object(subprocess, "Popen")
+def test_handle_signal_multiple(popen_mock: MagicMock) -> None:
+    popen_mock.return_value.stdout.read1.side_effect = lambda _: time.sleep(1)
+    pg_manager = ProcessGroupManager.from_args("sleep 0.1", "::", "sleep 0.2")
+    pg_manager.run()
+
+    pg_manager.handle_signal(signum=signal.SIGINT, _frame=MagicMock())
+    pg_manager.handle_signal(signum=signal.SIGINT, _frame=MagicMock())
+
+    send_signal_mock: MagicMock = popen_mock.return_value.send_signal
+    assert send_signal_mock.call_count == 4
+    send_signal_mock.assert_has_calls(
+        [
+            call(signal.SIGINT),
+            call(signal.SIGINT),
+            call(signal.SIGKILL),
+            call(signal.SIGKILL),
+        ]
+    )

{pyallel-2.0.6 → pyallel-2.1.0}/uv.lock

@@ -175,7 +175,7 @@ wheels = [
 
 [[package]]
 name = "pyallel"
-version = "2.0.6"
+version = "2.1.0"
 source = { editable = "." }
 
 [package.dev-dependencies]