pyallel 1.3.4__tar.gz → 1.3.5__tar.gz

{pyallel-1.3.4 → pyallel-1.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyallel
-Version: 1.3.4
+Version: 1.3.5
 Summary: Run and handle the output of multiple executables in pyallel (as in parallel)
 Home-page: https://github.com/Danthewaann/pyallel
 License: MIT

{pyallel-1.3.4 → pyallel-1.3.5}/pyproject.toml

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

{pyallel-1.3.4 → pyallel-1.3.5}/src/pyallel/colours.py

@@ -13,11 +13,6 @@ class Colours:
     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"

pyallel-1.3.5/src/pyallel/main.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import importlib.metadata
+import sys
+import time
+import traceback
+
+from pyallel import constants
+from pyallel.colours import Colours
+from pyallel.errors import InvalidLinesModifierError
+from pyallel.parser import Arguments, create_parser
+from pyallel.printer import (
+    InteractiveConsolePrinter,
+    NonInteractiveConsolePrinter,
+    Printer,
+)
+from pyallel.process_group_manager import ProcessGroupManager
+
+
+def entry_point(*args: str) -> int:
+    args = args or tuple(sys.argv[1:])
+    parser = create_parser()
+    parsed_args = parser.parse_args(args=args, namespace=Arguments())
+
+    if parsed_args.version:
+        my_version = importlib.metadata.version("pyallel")
+        print(my_version)
+        return 0
+
+    if not parsed_args.commands:
+        parser.print_help()
+        return 2
+
+    colours = Colours.from_colour(parsed_args.colour)
+    printer: Printer
+    if not parsed_args.interactive or not constants.IN_TTY:
+        printer = NonInteractiveConsolePrinter(colours, timer=parsed_args.timer)
+    else:
+        printer = InteractiveConsolePrinter(colours, timer=parsed_args.timer)
+
+    try:
+        process_group_manager = ProcessGroupManager.from_args(*parsed_args.commands)
+    except InvalidLinesModifierError as e:
+        print(f"{colours.red_bold}Error: {str(e)}{colours.reset_colour}")
+        return 1
+
+    try:
+        exit_code = run(process_group_manager, printer)
+    except Exception:
+        print(
+            f"{colours.red_bold}Error: {traceback.format_exc()}{colours.reset_colour}"
+        )
+        return 1
+
+    if exit_code == 1:
+        print(f"{colours.red_bold}\nFailed!{colours.reset_colour}")
+    elif exit_code == 0:
+        print(f"{colours.green_bold}\nDone!{colours.reset_colour}")
+
+    return exit_code
+
+
+def run(process_group_manager: ProcessGroupManager, printer: Printer) -> int:
+    process_group_manager.run()
+    while True:
+        process_group_manager.stream()
+        printer.print(process_group_manager)
+
+        poll = process_group_manager.poll()
+        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
+            if process_group_manager.stream().has_output():
+                printer.print(process_group_manager)
+
+            if poll > 0:
+                return poll
+
+            process_group_manager.run()
+            if not process_group_manager.next():
+                return 0
+
+        time.sleep(0.1)
+
+
+if __name__ == "__main__":
+    sys.exit(entry_point())

{pyallel-1.3.4 → pyallel-1.3.5}/src/pyallel/printer.py

@@ -1,20 +1,30 @@
 from __future__ import annotations
 
 import time
+from typing import Protocol
 
 from pyallel import constants
 from pyallel.colours import Colours
-from pyallel.process import ProcessOutput
+from pyallel.process import Process, ProcessOutput
 from pyallel.process_group import ProcessGroupOutput
+from pyallel.process_group_manager import ProcessGroupManager
 
 
-class Printer:
+class Printer(Protocol):
+    def print(self, process_group_manager: ProcessGroupManager) -> None:
+        """Print output obtained from the provided process group manager.
+
+        Args:
+            process_group_manager: manager to obtain output from
+        """
+
+
+class ConsolePrinter:
     def __init__(self, colours: Colours | None = None, timer: bool = False) -> None:
         self._colours = colours or Colours()
         self._timer = timer
         self._prefix = f"{self._colours.dim_on}=>{self._colours.dim_off} "
         self._icon = 0
-        self._last_printed: list[tuple[bool, str, str]] = []
         self._to_print: list[tuple[bool, str, str]] = []
 
     def write(
@@ -33,34 +43,10 @@ class Printer:
             truncate_num = 6
         if truncate:
             columns = columns - truncate_num
-            if get_num_lines(line, columns) > 1:
-                line = truncate_line(line, columns)
+            if self.get_num_lines(line, columns) > 1:
+                line = self.truncate_line(line, columns)
         print(f"{prefix}{line}", end=end, flush=flush)
 
-    def info(self, msg: str) -> None:
-        self.write(
-            f"{self._colours.white_bold}{msg}{self._colours.reset_colour}",
-            include_prefix=False,
-        )
-
-    def ok(self, msg: str) -> None:
-        self.write(
-            f"{self._colours.green_bold}{msg}{self._colours.reset_colour}",
-            include_prefix=False,
-        )
-
-    def warn(self, msg: str) -> None:
-        self.write(
-            f"{self._colours.yellow_bold}{msg}{self._colours.reset_colour}",
-            include_prefix=False,
-        )
-
-    def error(self, msg: str) -> None:
-        self.write(
-            f"{self._colours.red_bold}{msg}{self._colours.reset_colour}",
-            include_prefix=False,
-        )
-
     def generate_process_output(
         self,
         output: ProcessOutput,
@@ -154,12 +140,12 @@ class Printer:
             if not output.process.end:
                 end = time.perf_counter()
             elapsed = end - output.process.start
-            timer = f"({format_time_taken(elapsed)})"
+            timer = f"({self.format_time_taken(elapsed)})"
 
         command = output.process.command
-        if get_num_lines(output.process.command) > 1:
+        if self.get_num_lines(output.process.command) > 1:
             columns = constants.COLUMNS() - (len(msg) + len(timer) + 9)
-            command = truncate_line(command, columns)
+            command = self.truncate_line(command, columns)
 
         out = f"{self._colours.white_bold}[{self._colours.reset_colour}{self._colours.blue_bold}{command}{self._colours.reset_colour}{self._colours.white_bold}]{self._colours.reset_colour}{colour} {msg} {icon}{self._colours.reset_colour}"
 
@@ -174,7 +160,7 @@ class Printer:
         interrupt_count: int = 0,
         tail_output: bool = True,
     ) -> list[tuple[bool, str, str]]:
-        set_process_lines(output, interrupt_count)
+        self.set_process_lines(output, interrupt_count)
 
         for out in output.processes:
             self.generate_process_output(out, tail_output, append_newlines=True)
@@ -204,27 +190,124 @@ class Printer:
 
         return self._to_print
 
-    def print_process_output(
+    def set_process_lines(
         self,
-        output: ProcessOutput,
-        tail_output: bool = False,
-        include_cmd: bool = True,
-        include_output: bool = True,
-        include_progress: bool = True,
-        include_timer: bool | None = None,
+        output: ProcessGroupOutput,
+        interrupt_count: int = 0,
+        lines: int = 0,
     ) -> None:
-        for include_prefix, line, end in self.generate_process_output(
-            output,
-            tail_output,
-            include_cmd,
-            include_output,
-            include_progress,
-            include_timer,
-        ):
-            self.write(line, include_prefix, end)
+        lines = lines or constants.LINES() - 1
+        if interrupt_count:
+            lines -= 2
+
+        # Allocate lines to processes that have a fixed percentage of lines set
+        allocated_process_lines = lines // len(output.processes)
+        processes_with_dynamic_lines: list[ProcessOutput] = []
+        used_lines = 0
+        for process_output in output.processes:
+            # This process output doesn't have percentage_lines set, so skip it
+            if not process_output.process.percentage_lines:
+                processes_with_dynamic_lines.append(process_output)
+                continue
+
+            process_output.process.lines = int(
+                lines * process_output.process.percentage_lines
+            )
+            used_lines += process_output.process.lines
+
+        # Remove the used lines from the total available lines
+        lines -= used_lines
+
+        while lines:
+            # Calculate how many lines each process should have based on how many processes and lines are left
+            num_processes = len(processes_with_dynamic_lines) or 1
+            allocated_process_lines = lines // num_processes
+            processes_with_excess_output: list[ProcessOutput] = []
+            recalculate_lines = False
+            for process_output in processes_with_dynamic_lines:
+                # 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
+                if process_output.lines < allocated_process_lines:
+                    process_output.process.lines = process_output.lines
+                    lines -= process_output.process.lines
+                    recalculate_lines = True
+                    continue
+
+                processes_with_excess_output.append(process_output)
+
+            # We need to re-calcuate how many terminal lines we can allocate to each process if the output of at least one process
+            # 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:
+                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:
+                    process_output.process.lines = allocated_process_lines
+                    lines -= allocated_process_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:
+                    process_with_most_lines: ProcessOutput | None = None
+                    most_lines = 0
+                    for process_output in output.processes:
+                        if process_output.process.lines > most_lines:
+                            process_with_most_lines = process_output
+                            most_lines = process_output.process.lines
+
+                    if not process_with_most_lines:
+                        output.processes[0].process.lines += lines
+                    else:
+                        process_with_most_lines.process.lines += lines
+
+                break
+
+    def get_num_lines(self, line: str, columns: int | None = None) -> int:
+        lines = 0
+        columns = columns or constants.COLUMNS()
+        line = constants.ANSI_ESCAPE.sub("", line)
+        length = len(line)
+        line_lines = 1
+        if length > columns:
+            line_lines = length // columns
+            remainder = length % columns
+            if remainder:
+                line_lines += 1
+        lines += 1 * line_lines
+        return lines
+
+    def truncate_line(self, line: str, columns: int | None = None) -> str:
+        columns = columns or constants.COLUMNS()
+        escaped_line = constants.ANSI_ESCAPE.sub("", line)
+        return "".join(escaped_line[:columns]) + "..."
+
+    def format_time_taken(self, time_taken: float) -> str:
+        time_taken = round(time_taken, 1)
+        seconds = time_taken % (24 * 3600)
+
+        return f"{seconds}s"
 
-        # Force a flush otherwise lines that don't end in a newline character will not get printed as they are read
-        print("", end="", flush=True)
+
+class InteractiveConsolePrinter(ConsolePrinter):
+    def __init__(self, colours: Colours | None = None, timer: bool = False) -> None:
+        super().__init__(colours, timer)
+        self._last_printed: list[tuple[bool, str, str]] = []
+
+    def print(self, process_group_manager: ProcessGroupManager) -> None:
+        output = process_group_manager.get_cur_process_group_output()
+        self.print_progress_group_output(output, process_group_manager._interrupt_count)
+
+        poll = process_group_manager.poll()
+        if poll is not None:
+            self.clear_last_printed_lines()
+            self.reset()
+            self.print_progress_group_output(
+                output, process_group_manager._interrupt_count, tail_output=False
+            )
+            self.reset()
 
     def print_progress_group_output(
         self,
@@ -289,104 +372,48 @@ class Printer:
         self._to_print.clear()
 
 
-def set_process_lines(
-    output: ProcessGroupOutput,
-    interrupt_count: int = 0,
-    lines: int = 0,
-) -> None:
-    lines = lines or constants.LINES() - 1
-    if interrupt_count:
-        lines -= 2
-
-    # Allocate lines to processes that have a fixed percentage of lines set
-    allocated_process_lines = lines // len(output.processes)
-    processes_with_dynamic_lines: list[ProcessOutput] = []
-    used_lines = 0
-    for process_output in output.processes:
-        # This process output doesn't have percentage_lines set, so skip it
-        if not process_output.process.percentage_lines:
-            processes_with_dynamic_lines.append(process_output)
-            continue
-
-        process_output.process.lines = int(
-            lines * process_output.process.percentage_lines
-        )
-        used_lines += process_output.process.lines
-
-    # Remove the used lines from the total available lines
-    lines -= used_lines
-
-    while lines:
-        # Calculate how many lines each process should have based on how many processes and lines are left
-        num_processes = len(processes_with_dynamic_lines) or 1
-        allocated_process_lines = lines // num_processes
-        processes_with_excess_output: list[ProcessOutput] = []
-        recalculate_lines = False
-        for process_output in processes_with_dynamic_lines:
-            # 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
-            if process_output.lines < allocated_process_lines:
-                process_output.process.lines = process_output.lines
-                lines -= process_output.process.lines
-                recalculate_lines = True
-                continue
-
-            processes_with_excess_output.append(process_output)
-
-        # We need to re-calcuate how many terminal lines we can allocate to each process if the output of at least one process
-        # 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:
-            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:
-                process_output.process.lines = allocated_process_lines
-                lines -= allocated_process_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:
-                process_with_most_lines: ProcessOutput | None = None
-                most_lines = 0
-                for process_output in output.processes:
-                    if process_output.process.lines > most_lines:
-                        process_with_most_lines = process_output
-                        most_lines = process_output.process.lines
-
-                if not process_with_most_lines:
-                    output.processes[0].process.lines += lines
+class NonInteractiveConsolePrinter(ConsolePrinter):
+    def __init__(self, colours: Colours | None = None, timer: bool = False) -> None:
+        super().__init__(colours, timer)
+        self._current_process: Process | None = None
+
+    def print(self, process_group_manager: ProcessGroupManager) -> None:
+        outputs = process_group_manager.cur_output
+        for pg in outputs.process_group_outputs.values():
+            for output in pg.processes:
+                if self._current_process is None:
+                    self._current_process = output.process
+                    output = process_group_manager.get_process(output.id)
+                    self.print_process_output(
+                        output, include_progress=False, include_timer=False
+                    )
+                elif self._current_process is not output.process:
+                    continue
                 else:
-                    process_with_most_lines.process.lines += lines
-
-            break
-
+                    self.print_process_output(output, include_cmd=False)
 
-def get_num_lines(line: str, columns: int | None = None) -> int:
-    lines = 0
-    columns = columns or constants.COLUMNS()
-    line = constants.ANSI_ESCAPE.sub("", line)
-    length = len(line)
-    line_lines = 1
-    if length > columns:
-        line_lines = length // columns
-        remainder = length % columns
-        if remainder:
-            line_lines += 1
-    lines += 1 * line_lines
-    return lines
+                if output.process.poll() is not None:
+                    self.print_process_output(output, include_output=False)
+                    self._current_process = None
 
+    def print_process_output(
+        self,
+        output: ProcessOutput,
+        tail_output: bool = False,
+        include_cmd: bool = True,
+        include_output: bool = True,
+        include_progress: bool = True,
+        include_timer: bool | None = None,
+    ) -> None:
+        for include_prefix, line, end in self.generate_process_output(
+            output,
+            tail_output,
+            include_cmd,
+            include_output,
+            include_progress,
+            include_timer,
+        ):
+            self.write(line, include_prefix, end)
 
-def truncate_line(line: str, columns: int | None = None) -> str:
-    columns = columns or constants.COLUMNS()
-    escaped_line = constants.ANSI_ESCAPE.sub("", line)
-    return "".join(escaped_line[:columns]) + "..."
-
-
-def format_time_taken(time_taken: float) -> str:
-    time_taken = round(time_taken, 1)
-    seconds = time_taken % (24 * 3600)
-
-    return f"{seconds}s"
+        # Force a flush otherwise lines that don't end in a newline character will not get printed as they are read
+        print("", end="", flush=True)

{pyallel-1.3.4 → pyallel-1.3.5}/src/pyallel/process_group_manager.py

@@ -24,6 +24,14 @@ class ProcessGroupManagerOutput:
             else:
                 self.process_group_outputs[key] = value
 
+    def has_output(self) -> bool:
+        for pg in self.process_group_outputs.values():
+            for process in pg.processes:
+                if process.data:
+                    return True
+
+        return False
+
 
 class ProcessGroupManager:
     def __init__(self, process_groups: list[ProcessGroup]) -> None:
@@ -31,7 +39,7 @@ class ProcessGroupManager:
         self._interrupt_count = 0
         self._cur_process_group: ProcessGroup | None = None
         self._process_groups = process_groups
-        self._output = ProcessGroupManagerOutput(
+        self._all_output = ProcessGroupManagerOutput(
             process_group_outputs={
                 pg.id: ProcessGroupOutput(
                     id=pg.id,
@@ -40,6 +48,7 @@ class ProcessGroupManager:
                 for pg in self._process_groups
             }
         )
+        self.cur_output = ProcessGroupManagerOutput()
 
     def run(self) -> None:
         if self._process_groups:
@@ -62,18 +71,19 @@ class ProcessGroupManager:
             },
         )
 
-        self._output.merge(output)
+        self._all_output.merge(output)
+        self.cur_output = output
 
         return output
 
     def get_cur_process_group_output(self) -> ProcessGroupOutput:
         if self._cur_process_group:
-            return self._output.process_group_outputs[self._cur_process_group.id]
+            return self._all_output.process_group_outputs[self._cur_process_group.id]
 
         raise KeyError("no current process group output")
 
     def get_process(self, id: int) -> ProcessOutput:
-        for pg in self._output.process_group_outputs.values():
+        for pg in self._all_output.process_group_outputs.values():
             for process in pg.processes:
                 if process.id == id:
                     return process

pyallel-1.3.4/src/pyallel/main.py

@@ -1,137 +0,0 @@
-from __future__ import annotations
-
-import importlib.metadata
-import sys
-import traceback
-import time
-
-from pyallel import constants
-from pyallel.colours import Colours
-from pyallel.errors import InvalidLinesModifierError
-from pyallel.parser import Arguments, create_parser
-from pyallel.printer import Printer
-from pyallel.process_group_manager import ProcessGroupManager
-
-
-def run_interactive(
-    process_group_manager: ProcessGroupManager, printer: Printer
-) -> int:
-    while True:
-        process_group_manager.stream()
-
-        output = process_group_manager.get_cur_process_group_output()
-        printer.print_progress_group_output(
-            output, process_group_manager._interrupt_count
-        )
-
-        poll = process_group_manager.poll()
-        if poll is not None:
-            printer.clear_last_printed_lines()
-            printer.reset()
-            printer.print_progress_group_output(
-                output, process_group_manager._interrupt_count, tail_output=False
-            )
-
-            if poll > 0:
-                return poll
-
-            printer.reset()
-            process_group_manager.run()
-            if not process_group_manager.next():
-                return 0
-
-        time.sleep(0.1)
-
-
-def run_non_interactive(
-    process_group_manager: ProcessGroupManager, printer: Printer
-) -> int:
-    current_process = None
-
-    while True:
-        outputs = process_group_manager.stream()
-
-        for pg in outputs.process_group_outputs.values():
-            for output in pg.processes:
-                if current_process is None:
-                    current_process = output.process
-                    output = process_group_manager.get_process(output.id)
-                    printer.print_process_output(
-                        output, include_progress=False, include_timer=False
-                    )
-                elif current_process is not output.process:
-                    continue
-                else:
-                    printer.print_process_output(output, include_cmd=False)
-
-                if output.process.poll() is not None:
-                    printer.print_process_output(output, include_output=False)
-                    current_process = None
-
-        poll = process_group_manager.poll()
-        if poll is not None:
-            if poll > 0:
-                return poll
-
-            process_group_manager.run()
-            if not process_group_manager.next():
-                return 0
-
-        time.sleep(0.1)
-
-
-def run(*args: str) -> int:
-    parser = create_parser()
-    parsed_args = parser.parse_args(args=args, namespace=Arguments())
-
-    if parsed_args.version:
-        my_version = importlib.metadata.version("pyallel")
-        print(my_version)
-        return 0
-
-    if not parsed_args.commands:
-        parser.print_help()
-        return 2
-
-    colours = Colours.from_colour(parsed_args.colour)
-    printer = Printer(colours, timer=parsed_args.timer)
-
-    interactive = True
-    if not parsed_args.interactive:
-        interactive = False
-    elif not constants.IN_TTY:
-        interactive = False
-
-    message = None
-    try:
-        process_group_manager = ProcessGroupManager.from_args(*parsed_args.commands)
-        process_group_manager.run()
-
-        if interactive:
-            exit_code = run_interactive(process_group_manager, printer)
-        else:
-            exit_code = run_non_interactive(process_group_manager, printer)
-    except InvalidLinesModifierError as e:
-        exit_code = 1
-        message = str(e)
-    except Exception:
-        exit_code = 1
-        message = traceback.format_exc()
-
-    if exit_code == 1:
-        if not message:
-            printer.error("\nFailed!")
-        else:
-            printer.error(f"Error: {message}")
-    elif exit_code == 0:
-        printer.ok("\nDone!")
-
-    return exit_code
-
-
-def entry_point() -> None:
-    sys.exit(run(*sys.argv[1:]))
-
-
-if __name__ == "__main__":
-    entry_point()