pyallel 0.12.2__tar.gz → 0.14.0__tar.gz

{pyallel-0.12.2 → pyallel-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyallel
-Version: 0.12.2
+Version: 0.14.0
 Summary: Run and handle the output of multiple executables in pyallel (as in parallel)
 Home-page: https://github.com/Danthewaann/pyallel
 License: MIT
@@ -40,7 +40,7 @@ pip install pyallel
 Once installed, you can run `pyallel` to see usage information, like so:
 
 ```
-usage: pyallel [-h] [-t] [-n] [-s] [-V] [-v] [commands ...]
+usage: pyallel [-h] [-t] [-n] [-V] [-v] [commands ...]
 
 Run and handle the output of multiple executables in pyallel (as in parallel)
 
@@ -56,7 +56,6 @@ options:
   -t, --no-timer        don't time how long each command is taking
   -n, --non-interactive
                         run in non-interactive mode
-  -s, --no-stream       don't stream output of each command
   -V, --verbose         run in verbose mode
   -v, --version         print version and exit
 ```

{pyallel-0.12.2 → pyallel-0.14.0}/README.md

@@ -19,7 +19,7 @@ pip install pyallel
 Once installed, you can run `pyallel` to see usage information, like so:
 
 ```
-usage: pyallel [-h] [-t] [-n] [-s] [-V] [-v] [commands ...]
+usage: pyallel [-h] [-t] [-n] [-V] [-v] [commands ...]
 
 Run and handle the output of multiple executables in pyallel (as in parallel)
 
@@ -35,7 +35,6 @@ options:
   -t, --no-timer        don't time how long each command is taking
   -n, --non-interactive
                         run in non-interactive mode
-  -s, --no-stream       don't stream output of each command
   -V, --verbose         run in verbose mode
   -v, --version         print version and exit
 ```

{pyallel-0.12.2 → pyallel-0.14.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pyallel"
-version = "0.12.2"
+version = "0.14.0"
 description = "Run and handle the output of multiple executables in pyallel (as in parallel)"
 authors = ["Daniel Black <danielcrblack@gmail.com>"]
 license = "MIT"

{pyallel-0.12.2 → pyallel-0.14.0}/src/pyallel/main.py

@@ -15,13 +15,10 @@ def main_loop(
     interactive: bool = False,
     timer: bool = False,
     verbose: bool = False,
-    stream: bool = False,
 ) -> int:
     process_group = ProcessGroup.from_commands(
         *commands, interactive=interactive, timer=timer, verbose=verbose
     )
-    if not stream:
-        return process_group.run()
 
     return process_group.stream()
 
@@ -46,7 +43,6 @@ def run(*args: str) -> int:
             interactive=parsed_args.interactive,
             timer=parsed_args.timer,
             verbose=parsed_args.verbose,
-            stream=parsed_args.stream,
         )
     except InvalidExecutableErrors as e:
         exit_code = 1
@@ -55,14 +51,12 @@ def run(*args: str) -> int:
         exit_code = 1
         message = traceback.format_exc()
 
-    if exit_code == 2:
-        print(f"{constants.YELLOW_BOLD}Interrupt!{constants.RESET_COLOUR}")
-    elif exit_code == 1:
+    if exit_code == 1:
         if not message:
             print(f"{constants.RED_BOLD}A command failed!{constants.RESET_COLOUR}")
         else:
             print(f"{constants.RED_BOLD}Error: {message}{constants.RESET_COLOUR}")
-    else:
+    elif exit_code == 0:
         print(f"{constants.GREEN_BOLD}Success!{constants.RESET_COLOUR}")
 
     return exit_code

{pyallel-0.12.2 → pyallel-0.14.0}/src/pyallel/parser.py

@@ -9,7 +9,6 @@ class Arguments:
     timer: bool
     verbose: bool
     version: bool
-    stream: bool
 
     def __repr__(self) -> str:
         msg = "Arguments:\n"
@@ -54,14 +53,6 @@ def create_parser() -> ArgumentParser:
         dest="interactive",
         default=True,
     )
-    parser.add_argument(
-        "-s",
-        "--no-stream",
-        help="don't stream output of each command",
-        action="store_false",
-        default=True,
-        dest="stream",
-    )
     parser.add_argument(
         "-V",
         "--verbose",

{pyallel-0.12.2 → pyallel-0.14.0}/src/pyallel/process.py

@@ -9,7 +9,7 @@ import shlex
 import shutil
 import os
 from uuid import UUID, uuid4
-from typing import BinaryIO
+from typing import Any, BinaryIO
 from pyallel import constants
 
 from dataclasses import dataclass, field
@@ -74,26 +74,6 @@ def get_command_status(
     return output
 
 
-def print_command_output(process: Process) -> None:
-    output = process.read()
-    if output:
-        print(prefix(output.decode(), keepend=False))
-    print()
-
-
-def run_process(process: Process, timer: bool = False, verbose: bool = False) -> bool:
-    print(f"{constants.CLEAR_LINE}{constants.CARRIAGE_RETURN}", end="")
-
-    if process.return_code() != 0:
-        print(get_command_status(process, passed=False, verbose=verbose, timer=timer))
-        print_command_output(process)
-        return False
-    else:
-        print(get_command_status(process, passed=True, verbose=verbose, timer=timer))
-        print_command_output(process)
-        return True
-
-
 @dataclass
 class ProcessGroup:
     processes: list[Process]
@@ -103,43 +83,11 @@ class ProcessGroup:
     output: dict[UUID, list[str]] = field(default_factory=lambda: defaultdict(list))
     process_lines: list[int] = field(default_factory=list)
     completed_processes: set[UUID] = field(default_factory=set)
+    exit_code: int = 0
+    interrupt_count: int = 0
     passed: bool = True
     icon: int = 0
 
-    def run(self) -> int:
-        for process in self.processes:
-            process.run()
-
-        if not self.interactive or not constants.IN_TTY:
-            print(
-                f"{constants.WHITE_BOLD}Running commands...{constants.RESET_COLOUR}\n"
-            )
-
-        while True:
-            if self.interactive and constants.IN_TTY:
-                for icon in constants.ICONS:
-                    print(
-                        f"{constants.CLEAR_LINE}{constants.CARRIAGE_RETURN}{constants.WHITE_BOLD}Running commands{constants.RESET_COLOUR} {icon}",
-                        end="",
-                    )
-                    time.sleep(0.1)
-
-            for process in self.processes:
-                if process.id in self.completed_processes or process.poll() is None:
-                    continue
-
-                self.completed_processes.add(process.id)
-                process_passed = run_process(
-                    process, verbose=self.verbose, timer=self.timer
-                )
-                if not process_passed:
-                    self.passed = False
-
-            if len(self.completed_processes) == len(self.processes):
-                break
-
-        return 1 if not self.passed else 0
-
     def stream(self) -> int:
         for process in self.processes:
             process.run()
@@ -147,36 +95,31 @@ class ProcessGroup:
         if not self.interactive:
             return self.stream_non_interactive()
 
-        interrupted = False
-
         while True:
-            try:
-                output = self.complete_output()
-                self.icon += 1
-                if self.icon == len(constants.ICONS):
-                    self.icon = 0
+            output = self.complete_output()
+            self.icon += 1
+            if self.icon == len(constants.ICONS):
+                self.icon = 0
 
-                # Clear the screen and print the output
-                print(f"\033[H\033[0J{output}", end="")
+            # Clear the screen and print the output
+            print(f"\033[H\033[0J{output}", end="")
 
-                # Clear the screen again
-                print("\033[H\033[0J", end="")
+            # Clear the screen again
+            print("\033[H\033[0J", end="")
 
-                if len(self.completed_processes) == len(self.processes):
-                    break
+            if len(self.completed_processes) == len(self.processes):
+                break
 
-                time.sleep(0.1)
-            except KeyboardInterrupt:
-                interrupted = True
-                for process in self.processes:
-                    process.interrupt()
-                    process.wait()
+            time.sleep(0.1)
 
         output = self.complete_output(all=True)
         # Clear the screen one final time before printing the output
         print(f"\033[3J{output}")
 
-        return 2 if interrupted else (1 if not self.passed else 0)
+        if not self.exit_code and not self.passed:
+            self.exit_code = 1
+
+        return self.exit_code
 
     def stream_non_interactive(self) -> int:
         running_process = None
@@ -185,67 +128,88 @@ class ProcessGroup:
         print(f"{constants.WHITE_BOLD}Running commands...{constants.RESET_COLOUR}\n")
 
         while True:
-            try:
-                output = ""
-                for process in self.processes:
-                    if (
-                        running_process is None
-                        and process.id not in self.completed_processes
-                    ):
-                        output += get_command_status(process, verbose=self.verbose)
-                        output += "\n"
-                        running_process = process
-                    elif running_process is not process:
-                        # Need to do this to properly keep track of how long all the other
-                        # commands are taking
-                        process.poll()
-                        continue
+            output = ""
+            for process in self.processes:
+                if (
+                    running_process is None
+                    and process.id not in self.completed_processes
+                ):
+                    output += get_command_status(process, verbose=self.verbose)
+                    output += "\n"
+                    running_process = process
+                elif running_process is not process:
+                    # Need to do this to properly keep track of how long all the other
+                    # commands are taking
+                    process.poll()
+                    continue
 
-                    process_output = process.readline().decode()
+                process_output = process.readline().decode()
 
-                    if not self.output[process.id] and process_output:
+                if not self.output[process.id] and process_output:
+                    process_output = prefix(process_output)
+                    self.output[process.id].append(process_output)
+                    output += process_output
+                elif process_output:
+                    if self.output[process.id][-1][-1] != "\n":
+                        self.output[process.id][-1] += process_output
+                    else:
                         process_output = prefix(process_output)
                         self.output[process.id].append(process_output)
-                        output += process_output
-                    elif process_output:
-                        if self.output[process.id][-1][-1] != "\n":
-                            self.output[process.id][-1] += process_output
-                        else:
-                            process_output = prefix(process_output)
-                            self.output[process.id].append(process_output)
-                        output += process_output
-
-                    if process.poll() is not None:
-                        if process.return_code() != 0:
-                            self.passed = False
-                        process_output = process.read().decode()
-                        if process_output:
-                            output += prefix(process_output)
-
-                        output += get_command_status(
-                            process,
-                            passed=process.return_code() == 0,
-                            verbose=self.verbose,
-                            timer=self.timer,
-                        )
-                        output += "\n\n"
-                        self.completed_processes.add(process.id)
-                        running_process = None
-
-                if output:
-                    print(output, end="")
-
-                if len(self.completed_processes) == len(self.processes):
-                    break
-
-                time.sleep(0.01)
-            except KeyboardInterrupt:
-                interrupted = True
-                for process in self.processes:
-                    process.interrupt()
-                    process.wait()
-
-        return 2 if interrupted else (1 if not self.passed else 0)
+                    output += process_output
+
+                if process.poll() is not None:
+                    if process.return_code() != 0:
+                        self.passed = False
+                    process_output = process.read().decode()
+                    if process_output:
+                        output += prefix(process_output)
+
+                    output += get_command_status(
+                        process,
+                        passed=process.return_code() == 0,
+                        verbose=self.verbose,
+                        timer=self.timer,
+                    )
+                    output += "\n\n"
+                    self.completed_processes.add(process.id)
+                    running_process = None
+
+                if self.interrupt_count == 0:
+                    pass
+                elif not interrupted and self.interrupt_count == 1:
+                    if (output and output[-1] != "\n") or (
+                        self.output[process.id]
+                        and self.output[process.id][-1][-1] != "\n"
+                    ):
+                        output += "\n"
+                    output += f"\n{constants.YELLOW_BOLD}Interrupt!{constants.RESET_COLOUR}\n\n"
+                    interrupted = True
+
+            if output:
+                print(output, end="")
+
+            if len(self.completed_processes) == len(self.processes):
+                break
+
+            time.sleep(0.01)
+
+        if self.interrupt_count == 2:
+            print(f"{constants.RED_BOLD}Abort!{constants.RESET_COLOUR}")
+
+        if not self.exit_code and not self.passed:
+            self.exit_code = 1
+
+        return self.exit_code
+
+    def _handle_signal(self, signum: int, _frame: Any) -> None:
+        for process in self.processes:
+            if self.interrupt_count == 0:
+                process.interrupt()
+            else:
+                process.kill()
+
+        self.exit_code = 128 + signum
+        self.interrupt_count += 1
 
     @classmethod
     def from_commands(
@@ -267,13 +231,18 @@ class ProcessGroup:
         if errors:
             raise InvalidExecutableErrors(*errors)
 
-        return cls(
+        process_group = cls(
             processes=processes,
             interactive=interactive,
             timer=timer,
             verbose=verbose,
         )
 
+        signal.signal(signal.SIGINT, process_group._handle_signal)
+        signal.signal(signal.SIGTERM, process_group._handle_signal)
+
+        return process_group
+
     def complete_output(self, tail: int = 20, all: bool = False) -> str:
         num_processes = len(self.processes)
         lines = constants.LINES() - (2 * num_processes)
@@ -330,6 +299,14 @@ class ProcessGroup:
                 if i != num_processes:
                     output += "\n"
 
+        if self.interrupt_count == 0:
+            return output
+
+        if self.interrupt_count == 1:
+            output += f"\n{constants.YELLOW_BOLD}Interrupt!{constants.RESET_COLOUR}"
+        elif self.interrupt_count == 2:
+            output += f"\n{constants.RED_BOLD}Abort!{constants.RESET_COLOUR}"
+
         return output
 
 
@@ -395,6 +372,10 @@ class Process:
         if self._process:
             self._process.send_signal(signal.SIGINT)
 
+    def kill(self) -> None:
+        if self._process:
+            self._process.send_signal(signal.SIGKILL)
+
     def wait(self) -> int:
         if self._process:
             return self._process.wait()