pyallel 0.13.0__tar.gz → 0.15.0__tar.gz

{pyallel-0.13.0 → pyallel-0.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyallel
-Version: 0.13.0
+Version: 0.15.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] [-V] [-v] [commands ...]
+usage: pyallel [-h] [-t] [-n] [-V] [-v] [--colour {yes,no,auto}] [commands ...]
 
 Run and handle the output of multiple executables in pyallel (as in parallel)
 
@@ -58,6 +58,8 @@ options:
                         run in non-interactive mode
   -V, --verbose         run in verbose mode
   -v, --version         print version and exit
+  --colour {yes,no,auto}
+                        colour terminal output, defaults to "auto"
 ```
 
 Currently you can provide a variable number of `commands` to run to `pyallel`, like so:
@@ -94,6 +96,7 @@ pyallel "MYPY_FORCE_COLOR=1 mypy ." \
 - [x] Maybe make tail mode followed by an optional dump of all the command output once it
       finishes the default behaviour?
 - [x] Add graceful Ctrl-C interrupt handling to streamed modes
+- [x] Add a `--colour` flag to configure pyallel print colours
 - [ ] Setup build system to convert `pyallel` into a single file executable for ease of
       use and distribution
 - [ ] Add custom parsing of command output to support filtering for errors (like vim's

{pyallel-0.13.0 → pyallel-0.15.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] [-V] [-v] [commands ...]
+usage: pyallel [-h] [-t] [-n] [-V] [-v] [--colour {yes,no,auto}] [commands ...]
 
 Run and handle the output of multiple executables in pyallel (as in parallel)
 
@@ -37,6 +37,8 @@ options:
                         run in non-interactive mode
   -V, --verbose         run in verbose mode
   -v, --version         print version and exit
+  --colour {yes,no,auto}
+                        colour terminal output, defaults to "auto"
 ```
 
 Currently you can provide a variable number of `commands` to run to `pyallel`, like so:
@@ -73,6 +75,7 @@ pyallel "MYPY_FORCE_COLOR=1 mypy ." \
 - [x] Maybe make tail mode followed by an optional dump of all the command output once it
       finishes the default behaviour?
 - [x] Add graceful Ctrl-C interrupt handling to streamed modes
+- [x] Add a `--colour` flag to configure pyallel print colours
 - [ ] Setup build system to convert `pyallel` into a single file executable for ease of
       use and distribution
 - [ ] Add custom parsing of command output to support filtering for errors (like vim's

{pyallel-0.13.0 → pyallel-0.15.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pyallel"
-version = "0.13.0"
+version = "0.15.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.15.0/src/pyallel/colours.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, fields
+from typing import Literal
+from pyallel import constants
+
+
+@dataclass
+class Colours:
+    white_bold: str = "\033[1m"
+    green_bold: str = "\033[1;32m"
+    blue_bold: str = "\033[1;34m"
+    red_bold: str = "\033[1;31m"
+    yellow_bold: str = "\033[1;33m"
+    clear_line: str = "\033[2K"
+    clear_screen: str = "\033[2J"
+    save_cursor: str = "\033[s"
+    restore_cursor: str = "\033[u"
+    up_line: str = "\033[1F"
+    reset_colour: str = "\033[0m"
+    dim_on: str = "\033[2m"
+    dim_off: str = "\033[22m"
+
+    @classmethod
+    def from_colour(cls, colour: Literal["yes", "no", "auto"]) -> Colours:
+        colours = cls()
+
+        if colour == "no" or colour == "auto" and not constants.IN_TTY:
+            for field in fields(colours):
+                setattr(colours, field.name, "")
+
+        return colours

pyallel-0.15.0/src/pyallel/constants.py

@@ -0,0 +1,21 @@
+import os
+import sys
+
+IN_TTY = sys.stdout.isatty()
+
+
+if IN_TTY:
+
+    def LINES() -> int:
+        return os.get_terminal_size().lines
+
+else:
+
+    def LINES() -> int:
+        return sys.maxsize
+
+
+ICONS = ("/", "-", "\\", "|")
+# Unicode character bytes to render different symbols in the terminal
+TICK = "\u2713"
+X = "\u2717"

{pyallel-0.13.0 → pyallel-0.15.0}/src/pyallel/main.py

@@ -3,21 +3,26 @@ from __future__ import annotations
 import sys
 import traceback
 import importlib.metadata
+from pyallel.colours import Colours
 from pyallel.errors import InvalidExecutableErrors
 
 from pyallel.parser import Arguments, create_parser
 from pyallel.process import ProcessGroup
-from pyallel import constants
 
 
 def main_loop(
     *commands: str,
+    colours: Colours,
     interactive: bool = False,
     timer: bool = False,
     verbose: bool = False,
 ) -> int:
     process_group = ProcessGroup.from_commands(
-        *commands, interactive=interactive, timer=timer, verbose=verbose
+        *commands,
+        colours=colours,
+        interactive=interactive,
+        timer=timer,
+        verbose=verbose,
     )
 
     return process_group.stream()
@@ -36,10 +41,13 @@ def run(*args: str) -> int:
         parser.print_help()
         return 2
 
+    colours = Colours.from_colour(parsed_args.colour)
+
     message = None
     try:
         exit_code = main_loop(
             *parsed_args.commands,
+            colours=colours,
             interactive=parsed_args.interactive,
             timer=parsed_args.timer,
             verbose=parsed_args.verbose,
@@ -51,15 +59,13 @@ 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}")
+            print(f"{colours.red_bold}A command failed!{colours.reset_colour}")
         else:
-            print(f"{constants.RED_BOLD}Error: {message}{constants.RESET_COLOUR}")
-    else:
-        print(f"{constants.GREEN_BOLD}Success!{constants.RESET_COLOUR}")
+            print(f"{colours.red_bold}Error: {message}{colours.reset_colour}")
+    elif exit_code == 0:
+        print(f"{colours.green_bold}Success!{colours.reset_colour}")
 
     return exit_code
 

{pyallel-0.13.0 → pyallel-0.15.0}/src/pyallel/parser.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
 from argparse import ArgumentParser, RawTextHelpFormatter
+from typing import Literal
 
 
 class Arguments:
+    colour: Literal["yes", "no", "auto"]
     commands: list[str]
     interactive: bool
     timer: bool
@@ -67,5 +69,11 @@ def create_parser() -> ArgumentParser:
         action="store_true",
         default=False,
     )
+    parser.add_argument(
+        "--colour",
+        help="colour terminal output, defaults to \"%(default)s\"",
+        choices=("yes", "no", "auto"),
+        default="auto",
+    )
 
     return parser

{pyallel-0.13.0 → pyallel-0.15.0}/src/pyallel/process.py

@@ -9,23 +9,14 @@ 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
+from pyallel.colours import Colours
 from pyallel.errors import InvalidExecutableErrors, InvalidExecutableError
 
 
-def prefix(output: str, keepend: bool = True) -> str:
-    prefixed_output = "\n".join(
-        f"{constants.DIM_ON}=>{constants.DIM_OFF} {line}{constants.RESET_COLOUR}"
-        for line in output.splitlines()
-    )
-    if keepend and output and output[-1] == "\n":
-        prefixed_output += "\n"
-    return prefixed_output
-
-
 def format_time_taken(time_taken: float) -> str:
     time_taken = round(time_taken, 1)
     seconds = time_taken % (24 * 3600)
@@ -33,47 +24,6 @@ def format_time_taken(time_taken: float) -> str:
     return f"{seconds}s"
 
 
-def get_command_status(
-    process: Process,
-    icon: str | None = None,
-    passed: bool | None = None,
-    verbose: bool = False,
-    timer: bool = False,
-) -> str:
-    if passed is True:
-        colour = constants.GREEN_BOLD
-        msg = "done"
-        icon = icon or constants.TICK
-    elif passed is False:
-        colour = constants.RED_BOLD
-        msg = "failed"
-        icon = icon or constants.X
-    else:
-        colour = constants.WHITE_BOLD
-        msg = "running"
-        icon = icon or ""
-        if not icon:
-            msg += "..."
-
-    output = f"[{constants.BLUE_BOLD}{process.name}"
-
-    if verbose:
-        output += f" {' '.join(process.args)}"
-
-    output += f"{constants.RESET_COLOUR}]{colour} {msg} {icon}{constants.RESET_COLOUR}"
-
-    if timer:
-        end = process.end
-        if not process.end:
-            end = time.perf_counter()
-        elapsed = end - process.start
-        output += (
-            f" ({constants.DIM_ON}{format_time_taken(elapsed)}{constants.DIM_OFF})"
-        )
-
-    return output
-
-
 @dataclass
 class ProcessGroup:
     processes: list[Process]
@@ -83,8 +33,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
+    colours: Colours = field(default_factory=Colours)
 
     def stream(self) -> int:
         for process in self.processes:
@@ -93,110 +46,177 @@ 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
         interrupted = False
 
-        print(f"{constants.WHITE_BOLD}Running commands...{constants.RESET_COLOUR}\n")
+        print(
+            f"{self.colours.white_bold}Running commands...{self.colours.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 = ""
+            for process in self.processes:
+                if (
+                    running_process is None
+                    and process.id not in self.completed_processes
+                ):
+                    output += self._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()
+
+                if not self.output[process.id] and process_output:
+                    process_output = self._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 = self._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 += self._prefix(process_output)
+
+                    output += self._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 += 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 += f"\n{self.colours.yellow_bold}Interrupt!{self.colours.reset_colour}\n\n"
+                    interrupted = True
 
-                    process_output = process.readline().decode()
+            if output:
+                print(output, end="")
 
-                    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
-
-                    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)
+            if len(self.completed_processes) == len(self.processes):
+                break
+
+            time.sleep(0.01)
+
+        if self.interrupt_count == 2:
+            print(f"{self.colours.red_bold}Abort!{self.colours.reset_colour}")
+
+        if not self.exit_code and not self.passed:
+            self.exit_code = 1
+
+        return self.exit_code
+
+    def _prefix(self, output: str, keepend: bool = True) -> str:
+        prefixed_output = "\n".join(
+            f"{self.colours.dim_on}=>{self.colours.dim_off} {line}{self.colours.reset_colour}"
+            for line in output.splitlines()
+        )
+        if keepend and output and output[-1] == "\n":
+            prefixed_output += "\n"
+        return prefixed_output
+
+    def _get_command_status(
+        self,
+        process: Process,
+        icon: str | None = None,
+        passed: bool | None = None,
+        verbose: bool = False,
+        timer: bool = False,
+    ) -> str:
+        if passed is True:
+            colour = self.colours.green_bold
+            msg = "done"
+            icon = icon or constants.TICK
+        elif passed is False:
+            colour = self.colours.red_bold
+            msg = "failed"
+            icon = icon or constants.X
+        else:
+            colour = self.colours.white_bold
+            msg = "running"
+            icon = icon or ""
+            if not icon:
+                msg += "..."
+
+        output = f"[{self.colours.blue_bold}{process.name}"
+
+        if verbose:
+            output += f" {' '.join(process.args)}"
+
+        output += f"{self.colours.reset_colour}]{colour} {msg} {icon}{self.colours.reset_colour}"
+
+        if timer:
+            end = process.end
+            if not process.end:
+                end = time.perf_counter()
+            elapsed = end - process.start
+            output += f" ({self.colours.dim_on}{format_time_taken(elapsed)}{self.colours.dim_off})"
+
+        return output
+
+    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(
         cls,
         *commands: str,
+        colours: Colours,
         interactive: bool = False,
         timer: bool = False,
         verbose: bool = False,
@@ -213,13 +233,19 @@ class ProcessGroup:
         if errors:
             raise InvalidExecutableErrors(*errors)
 
-        return cls(
+        process_group = cls(
             processes=processes,
             interactive=interactive,
             timer=timer,
             verbose=verbose,
+            colours=colours,
         )
 
+        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)
@@ -243,7 +269,7 @@ class ProcessGroup:
                 self.completed_processes.add(process.id)
                 if process.return_code() != 0:
                     self.passed = False
-                output += get_command_status(
+                output += self._get_command_status(
                     process,
                     passed=process.return_code() == 0,
                     verbose=self.verbose,
@@ -251,7 +277,7 @@ class ProcessGroup:
                 )
                 output += "\n"
             else:
-                output += get_command_status(
+                output += self._get_command_status(
                     process,
                     icon=constants.ICONS[self.icon],
                     verbose=self.verbose,
@@ -270,12 +296,22 @@ class ProcessGroup:
                         process_output.splitlines()[-self.process_lines[i - 1] :]
                     )
                     process_output += "\n"
-                output += prefix(process_output)
+                output += self._prefix(process_output)
                 if output and output[-1] != "\n":
                     output += "\n"
                 if i != num_processes:
                     output += "\n"
 
+        if self.interrupt_count == 0:
+            return output
+
+        if self.interrupt_count == 1:
+            output += (
+                f"\n{self.colours.yellow_bold}Interrupt!{self.colours.reset_colour}"
+            )
+        elif self.interrupt_count == 2:
+            output += f"\n{self.colours.red_bold}Abort!{self.colours.reset_colour}"
+
         return output
 
 
@@ -341,6 +377,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()

pyallel-0.13.0/src/pyallel/constants.py

@@ -1,55 +0,0 @@
-import os
-import sys
-
-IN_TTY = sys.stdout.isatty()
-
-
-if IN_TTY:
-    WHITE_BOLD = "\033[1m"
-    GREEN_BOLD = "\033[1;32m"
-    BLUE_BOLD = "\033[1;34m"
-    RED_BOLD = "\033[1;31m"
-    YELLOW_BOLD = "\033[1;33m"
-    CLEAR_LINE = "\033[2K"
-    CLEAR_SCREEN = "\033[2J"
-    SAVE_CURSOR = "\033[s"
-    RESTORE_CURSOR = "\033[u"
-    UP_LINE = "\033[1F"
-    RESET_COLOUR = "\033[0m"
-    CARRIAGE_RETURN = "\r"
-    DIM_ON = "\033[2m"
-    DIM_OFF = "\033[22m"
-
-    def COLUMNS() -> int:
-        return os.get_terminal_size().columns
-
-    def LINES() -> int:
-        return os.get_terminal_size().lines
-
-else:
-    WHITE_BOLD = ""
-    GREEN_BOLD = ""
-    BLUE_BOLD = ""
-    RED_BOLD = ""
-    YELLOW_BOLD = ""
-    CLEAR_LINE = ""
-    CLEAR_SCREEN = ""
-    SAVE_CURSOR = ""
-    RESTORE_CURSOR = ""
-    UP_LINE = ""
-    RESET_COLOUR = ""
-    CARRIAGE_RETURN = ""
-    DIM_ON = ""
-    DIM_OFF = ""
-
-    def COLUMNS() -> int:
-        return sys.maxsize
-
-    def LINES() -> int:
-        return sys.maxsize
-
-
-ICONS = ("/", "-", "\\", "|")
-# Unicode character bytes to render different symbols in the terminal
-TICK = "\u2713"
-X = "\u2717"