pyallel 1.2.5__tar.gz → 1.2.7__tar.gz

{pyallel-1.2.5 → pyallel-1.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyallel
-Version: 1.2.5
+Version: 1.2.7
 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.2.5 → pyallel-1.2.7}/pyproject.toml

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

pyallel-1.2.7/src/pyallel/main.py

@@ -0,0 +1,137 @@
+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 InvalidExecutableErrors
+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()
+
+        printer.clear_printed_lines()
+        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_printed_lines()
+            printer.print_progress_group_output(
+                output, process_group_manager._interrupt_count, tail_output=False
+            )
+
+            if poll > 0:
+                return poll
+
+            printer.clear()
+            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 InvalidExecutableErrors 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()

pyallel-1.2.7/src/pyallel/printer.py

@@ -0,0 +1,275 @@
+from __future__ import annotations
+
+import time
+
+from pyallel import constants
+from pyallel.colours import Colours
+from pyallel.process import ProcessOutput
+from pyallel.process_group import ProcessGroupOutput
+
+
+class Printer:
+    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._printed: list[tuple[bool, str, str]] = []
+
+    def write(
+        self,
+        line: str,
+        include_prefix: bool = False,
+        end: str = "\n",
+        truncate: bool = False,
+    ) -> None:
+        prefix = self._prefix if include_prefix else ""
+        if truncate:
+            columns = constants.COLUMNS() - len(prefix)
+            if get_num_lines(line, columns) > 1:
+                line = truncate_line(line, columns)
+        print(f"{prefix}{line}", end=end, flush=True)
+
+    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,
+        tail_output: bool = False,
+        include_cmd: bool = True,
+        include_output: bool = True,
+        include_progress: bool = True,
+        include_timer: bool | None = None,
+        append_newlines: bool = False,
+    ) -> list[tuple[bool, str, str]]:
+        out: list[tuple[bool, str, str]] = []
+        line_parts: tuple[bool, str, str]
+
+        if include_cmd:
+            status = self.generate_process_output_status(
+                output, include_progress, include_timer
+            )
+            line_parts = (False, status, "\n")
+            out.append(line_parts)
+            self._printed.append(line_parts)
+
+        if include_output:
+            lines = output.data.splitlines(keepends=True)
+
+            if tail_output:
+                status_lines = get_num_lines(status)
+                output_lines = output.lines - status_lines
+                lines = lines[-output_lines:]
+
+            for line in lines:
+                prefix = True
+                end = line[-1]
+                if append_newlines and end != "\n":
+                    end = "\n"
+                else:
+                    line = line[:-1]
+
+                try:
+                    prev_line = self._printed[-1]
+                except IndexError:
+                    pass
+                else:
+                    if prev_line[2] != "\n":
+                        prefix = False
+
+                line_parts = (prefix, line, end)
+                out.append(line_parts)
+                self._printed.append(line_parts)
+
+        return out
+
+    def generate_process_output_status(
+        self,
+        output: ProcessOutput,
+        include_progress: bool = True,
+        include_timer: bool | None = None,
+    ) -> str:
+        include_timer = include_timer if include_timer is not None else self._timer
+
+        passed = None
+        icon = ""
+        poll = output.process.poll()
+        if include_progress:
+            icon = constants.ICONS[self._icon]
+            if poll is not None:
+                passed = poll == 0
+
+        if passed is True:
+            colour = self._colours.green_bold
+            msg = "done"
+            icon = constants.TICK
+        elif passed is False:
+            colour = self._colours.red_bold
+            msg = "failed"
+            icon = constants.X
+        else:
+            colour = self._colours.white_bold
+            msg = "running"
+
+            if not icon:
+                msg += "..."
+
+        out = f"{self._colours.white_bold}[{self._colours.reset_colour}{self._colours.blue_bold}{output.process.command}{self._colours.reset_colour}{self._colours.white_bold}]{self._colours.reset_colour}{colour} {msg} {icon}{self._colours.reset_colour}"
+
+        if include_timer:
+            end = output.process.end
+            if not output.process.end:
+                end = time.perf_counter()
+            elapsed = end - output.process.start
+            out += f" {self._colours.dim_on}({format_time_taken(elapsed)}){self._colours.dim_off}"
+
+        return out
+
+    def generate_process_group_output(
+        self,
+        output: ProcessGroupOutput,
+        interrupt_count: int = 0,
+        tail_output: bool = True,
+    ) -> list[tuple[bool, str, str]]:
+        set_process_lines(output, interrupt_count)
+
+        for out in output.processes:
+            self.generate_process_output(out, tail_output, append_newlines=True)
+
+        if interrupt_count == 1:
+            self._printed.append((False, "", "\n"))
+            self._printed.append(
+                (
+                    False,
+                    f"{self._colours.yellow_bold}Interrupt!{self._colours.reset_colour}",
+                    "\n",
+                )
+            )
+        elif interrupt_count == 2:
+            self._printed.append((False, "", "\n"))
+            self._printed.append(
+                (
+                    False,
+                    f"{self._colours.red_bold}Abort!{self._colours.reset_colour}",
+                    "\n",
+                )
+            )
+
+        self._icon += 1
+        if self._icon == len(constants.ICONS):
+            self._icon = 0
+
+        return self._printed
+
+    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 print_progress_group_output(
+        self,
+        output: ProcessGroupOutput,
+        interrupt_count: int = 0,
+        tail_output: bool = True,
+    ) -> None:
+        for include_prefix, line, end in self.generate_process_group_output(
+            output, interrupt_count, tail_output
+        ):
+            self.write(line, include_prefix, end, truncate=tail_output)
+
+    def clear_printed_lines(self) -> None:
+        # Clear all the lines that were just printed
+        for _, _, end in self._printed:
+            if end == "\n":
+                self.write(
+                    f"{constants.CLEAR_LINE}{constants.UP_LINE}{constants.CLEAR_LINE}",
+                    end="",
+                )
+
+        self.clear()
+
+    def clear(self) -> None:
+        self._printed.clear()
+
+
+def set_process_lines(
+    output: ProcessGroupOutput,
+    interrupt_count: int = 0,
+    lines: int | None = None,
+) -> None:
+    lines = lines or constants.LINES() - 1
+    if interrupt_count:
+        lines -= 2
+
+    num_processes = len(output.processes)
+    remainder = lines % num_processes
+    tail = lines // num_processes
+
+    for out in output.processes:
+        out.lines = tail
+    if remainder:
+        output.processes[-1].lines += remainder
+
+
+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
+
+
+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"

pyallel-1.2.7/src/pyallel/process.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import signal
+import subprocess
+import tempfile
+import time
+from typing import BinaryIO
+
+
+class ProcessOutput:
+    def __init__(self, id: int, process: Process, data: str = "") -> None:
+        self.id = id
+        self.data = data
+        self.process = process
+        self.lines = -1
+
+    def merge(self, other: ProcessOutput) -> None:
+        self.data += other.data
+
+
+class Process:
+    def __init__(self, id: int, command: str) -> None:
+        self.id = id
+        self.command = command
+        self.start = 0.0
+        self.end = 0.0
+        self._fd: BinaryIO
+        self._process: subprocess.Popen[bytes]
+
+    def run(self) -> None:
+        self.start = time.perf_counter()
+        fd, fd_name = tempfile.mkstemp()
+        self._fd = open(fd_name, "rb")
+        self._process = subprocess.Popen(
+            self.command,
+            stdin=subprocess.DEVNULL,
+            stdout=fd,
+            stderr=subprocess.STDOUT,
+            shell=True,
+        )
+
+    def __del__(self) -> None:
+        try:
+            self._fd.close()
+        except AttributeError:
+            pass
+
+    def poll(self) -> int | None:
+        poll = self._process.poll()
+        if poll is not None and not self.end:
+            self.end = time.perf_counter()
+        return poll
+
+    def read(self) -> bytes:
+        return self._fd.read()
+
+    def readline(self) -> bytes:
+        return self._fd.readline()
+
+    def return_code(self) -> int | None:
+        return self._process.returncode
+
+    def interrupt(self) -> None:
+        if hasattr(self, "_process"):
+            self._process.send_signal(signal.SIGINT)
+
+    def kill(self) -> None:
+        if hasattr(self, "_process"):
+            self._process.send_signal(signal.SIGKILL)
+
+    def wait(self) -> int:
+        return self._process.wait()
+

pyallel-1.2.7/src/pyallel/process_group.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+from typing import Sequence
+
+from pyallel.errors import InvalidExecutableError, InvalidExecutableErrors
+from pyallel.process import Process, ProcessOutput
+
+
+class ProcessGroupOutput:
+    def __init__(self, id: int, processes: Sequence[ProcessOutput]) -> None:
+        self.id = id
+        self.processes = processes
+
+    def merge(self, other: ProcessGroupOutput) -> None:
+        for i, _ in enumerate(self.processes):
+            self.processes[i].merge(other.processes[i])
+
+
+class ProcessGroup:
+    def __init__(self, id: int, processes: list[Process]) -> None:
+        self.id = id
+        self.processes = processes
+        self._exit_code: int = 0
+        self._interrupt_count: int = 0
+
+    def run(self) -> None:
+        for process in self.processes:
+            process.run()
+
+    def poll(self) -> int | None:
+        polls: list[int | None] = [process.poll() for process in self.processes]
+
+        running = [p for p in polls if p is None]
+        failed = [p for p in polls if p is not None and p > 0]
+
+        if running:
+            return None
+        elif failed:
+            return 1
+        else:
+            return 0
+
+    def stream(self) -> ProcessGroupOutput:
+        return ProcessGroupOutput(
+            id=self.id,
+            processes=[
+                ProcessOutput(
+                    id=process.id, process=process, data=process.read().decode()
+                )
+                for process in self.processes
+            ],
+        )
+
+    def handle_signal(self, _signum: int) -> None:
+        for process in self.processes:
+            if self._interrupt_count == 0:
+                process.interrupt()
+            else:
+                process.kill()
+
+        self._interrupt_count += 1
+
+    @classmethod
+    def from_commands(cls, id: int, process_id: int, *commands: str) -> ProcessGroup:
+        processes: list[Process] = []
+        errors: list[InvalidExecutableError] = []
+
+        for i, command in enumerate(commands):
+            try:
+                processes.append(Process(i + process_id, command))
+            except InvalidExecutableError as e:
+                errors.append(e)
+
+        if errors:
+            raise InvalidExecutableErrors(*errors)
+
+        process_group = cls(id=id, processes=processes)
+
+        return process_group

pyallel-1.2.7/src/pyallel/process_group_manager.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+import signal
+from typing import Any
+
+from pyallel.process import ProcessOutput
+from pyallel.process_group import ProcessGroupOutput, ProcessGroup
+
+
+class ProcessGroupManagerOutput:
+    def __init__(
+        self,
+        process_group_outputs: dict[int, ProcessGroupOutput] | None = None,
+        cur_process_group_id: int = 1,
+    ) -> None:
+        self.process_group_outputs = process_group_outputs or {}
+        self.cur_process_group_id = cur_process_group_id
+
+    def merge(self, other: ProcessGroupManagerOutput) -> None:
+        self.cur_process_group_id = other.cur_process_group_id
+        for key, value in other.process_group_outputs.items():
+            if key in self.process_group_outputs:
+                self.process_group_outputs[key].merge(value)
+            else:
+                self.process_group_outputs[key] = value
+
+
+class ProcessGroupManager:
+    def __init__(self, process_groups: list[ProcessGroup]) -> None:
+        self._exit_code = 0
+        self._interrupt_count = 0
+        self._cur_process_group: ProcessGroup | None = None
+        self._process_groups = process_groups
+        self._output = ProcessGroupManagerOutput(
+            process_group_outputs={
+                pg.id: ProcessGroupOutput(
+                    id=pg.id,
+                    processes=[ProcessOutput(id=p.id, process=p) for p in pg.processes],
+                )
+                for pg in self._process_groups
+            }
+        )
+
+    def run(self) -> None:
+        if self._process_groups:
+            self._cur_process_group = self._process_groups.pop(0)
+            self._cur_process_group.run()
+        else:
+            self._cur_process_group = None
+
+    def next(self) -> bool:
+        return True if self._cur_process_group or self._process_groups else False
+
+    def stream(self) -> ProcessGroupManagerOutput:
+        if self._cur_process_group is None:
+            return ProcessGroupManagerOutput()
+
+        output = ProcessGroupManagerOutput(
+            cur_process_group_id=self._cur_process_group.id,
+            process_group_outputs={
+                self._cur_process_group.id: self._cur_process_group.stream()
+            },
+        )
+
+        self._output.merge(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]
+
+        raise KeyError("no current process group output")
+
+    def get_process(self, id: int) -> ProcessOutput:
+        for pg in self._output.process_group_outputs.values():
+            for process in pg.processes:
+                if process.id == id:
+                    return process
+
+        raise KeyError(f"process with id '{id}' not found")
+
+    def poll(self) -> int | None:
+        if self._cur_process_group is None:
+            return 0
+
+        poll = self._cur_process_group.poll()
+
+        if poll is not None and self._exit_code:
+            return self._exit_code
+
+        if self._interrupt_count > 1:
+            return self._exit_code
+
+        return poll
+
+    def handle_signal(self, signum: int, _frame: Any) -> None:
+        for process_group in self._process_groups:
+            process_group.handle_signal(signum)
+
+        self._exit_code = 128 + signum
+        self._interrupt_count += 1
+
+    @classmethod
+    def from_args(cls, *args: str) -> ProcessGroupManager:
+        last_separator_index = 0
+        commands: list[str] = []
+        process_groups: list[ProcessGroup] = []
+        progress_group_id = 1
+        process_id = 1
+
+        for i, arg in enumerate(args):
+            if arg == ":::":
+                if i - 1 == 0:
+                    pg = ProcessGroup.from_commands(
+                        progress_group_id, process_id, args[0]
+                    )
+                else:
+                    pg = ProcessGroup.from_commands(
+                        progress_group_id, process_id, *commands[last_separator_index:]
+                    )
+
+                process_groups.append(pg)
+                process_id += len(pg.processes)
+                last_separator_index = i
+                progress_group_id += 1
+                continue
+
+            commands.append(arg)
+
+        if len(process_groups) > 1:
+            last_separator_index -= 1
+
+        process_groups.append(
+            ProcessGroup.from_commands(
+                progress_group_id, process_id, *commands[last_separator_index:]
+            )
+        )
+
+        process_group_manager = cls(process_groups=process_groups)
+
+        signal.signal(signal.SIGINT, process_group_manager.handle_signal)
+        signal.signal(signal.SIGTERM, process_group_manager.handle_signal)
+
+        return process_group_manager

pyallel-1.2.5/src/pyallel/main.py

@@ -1,88 +0,0 @@
-from __future__ import annotations
-
-import importlib.metadata
-import sys
-import traceback
-
-from pyallel import constants
-from pyallel.colours import Colours
-from pyallel.errors import InvalidExecutableErrors
-from pyallel.parser import Arguments, create_parser
-from pyallel.process_group_manager import ProcessGroupManager
-
-
-def main_loop(
-    *args: str,
-    colours: Colours,
-    interactive: bool = False,
-    timer: bool = False,
-) -> int:
-    process_group_manager = ProcessGroupManager.from_args(
-        *args,
-        colours=colours,
-        interactive=interactive,
-        timer=timer,
-    )
-
-    return process_group_manager.stream()
-
-
-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)
-
-    interactive = True
-    if not parsed_args.interactive:
-        interactive = False
-    elif not constants.IN_TTY:
-        interactive = False
-
-    message = None
-    try:
-        exit_code = main_loop(
-            *parsed_args.commands,
-            colours=colours,
-            interactive=interactive,
-            timer=parsed_args.timer,
-        )
-    except InvalidExecutableErrors as e:
-        exit_code = 1
-        message = str(e)
-    except Exception:
-        exit_code = 1
-        message = traceback.format_exc()
-
-    if exit_code == 1:
-        if not message:
-            print(
-                f"{colours.dim_on}=>{colours.dim_off} {colours.red_bold}Failed!{colours.reset_colour}"
-            )
-        else:
-            print(
-                f"{colours.dim_on}=>{colours.dim_off} {colours.red_bold}Error: {message}{colours.reset_colour}"
-            )
-    elif exit_code == 0:
-        print(
-            f"{colours.dim_on}=>{colours.dim_off} {colours.green_bold}Done!{colours.reset_colour}"
-        )
-
-    return exit_code
-
-
-def entry_point() -> None:
-    sys.exit(run(*sys.argv[1:]))
-
-
-if __name__ == "__main__":
-    entry_point()

pyallel-1.2.5/src/pyallel/process.py

@@ -1,72 +0,0 @@
-from __future__ import annotations
-
-import signal
-import subprocess
-import tempfile
-import time
-from dataclasses import dataclass, field
-from typing import BinaryIO
-
-
-@dataclass
-class Process:
-    id: int
-    command: str
-    start: float = 0.0
-    end: float = 0.0
-    _fd: BinaryIO | None = field(init=False, repr=False, compare=False, default=None)
-    _process: subprocess.Popen[bytes] | None = field(
-        init=False, repr=False, compare=False, default=None
-    )
-
-    def run(self) -> None:
-        self.start = time.perf_counter()
-        fd, fd_name = tempfile.mkstemp()
-        self._fd = open(fd_name, "rb")
-        self._process = subprocess.Popen(
-            self.command,
-            stdin=subprocess.DEVNULL,
-            stdout=fd,
-            stderr=subprocess.STDOUT,
-            shell=True,
-        )
-
-    def __del__(self) -> None:
-        if self._fd:
-            self._fd.close()
-
-    def poll(self) -> int | None:
-        if self._process:
-            poll = self._process.poll()
-            if poll is not None and not self.end:
-                self.end = time.perf_counter()
-            return poll
-        return None
-
-    def read(self) -> bytes:
-        if self._fd:
-            return self._fd.read()
-        return b""
-
-    def readline(self) -> bytes:
-        if self._fd:
-            return self._fd.readline()
-        return b""
-
-    def return_code(self) -> int | None:
-        if self._process:
-            return self._process.returncode
-        return None
-
-    def interrupt(self) -> None:
-        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()
-        return -1

pyallel-1.2.5/src/pyallel/process_group.py

@@ -1,328 +0,0 @@
-from __future__ import annotations
-
-import time
-from collections import defaultdict
-from dataclasses import dataclass, field
-
-from pyallel import constants
-from pyallel.colours import Colours
-from pyallel.errors import InvalidExecutableError, InvalidExecutableErrors
-from pyallel.process import Process
-
-
-def get_num_lines(output: str, columns: int | None = None) -> int:
-    lines = 0
-    columns = columns or constants.COLUMNS()
-    for line in output.splitlines():
-        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 format_time_taken(time_taken: float) -> str:
-    time_taken = round(time_taken, 1)
-    seconds = time_taken % (24 * 3600)
-
-    return f"{seconds}s"
-
-
-@dataclass
-class ProcessGroup:
-    processes: list[Process]
-    interactive: bool = False
-    timer: bool = False
-    output: dict[int, list[str]] = field(default_factory=lambda: defaultdict(list))
-    process_lines: list[int] = field(default_factory=list)
-    completed_processes: set[int] = 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 __post_init__(self) -> None:
-        self.process_lines = [0 for _ in self.processes]
-
-    def stream(self) -> int:
-        for process in self.processes:
-            process.run()
-
-        if not self.interactive:
-            return self.stream_non_interactive()
-
-        while True:
-            output = self.complete_output()
-            self.icon += 1
-            if self.icon == len(constants.ICONS):
-                self.icon = 0
-
-            print(output, end="", flush=True)
-
-            # Clear all the lines that were just printed
-            for _ in range(get_num_lines(output) - (1 if self.exit_code > 1 else 0)):
-                print(
-                    f"{constants.CLEAR_LINE}{constants.UP_LINE}{constants.CLEAR_LINE}",
-                    end="",
-                )
-
-            if len(self.completed_processes) == len(self.processes):
-                break
-
-            time.sleep(0.1)
-
-        print(self.complete_output(all=True), flush=True)
-
-        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
-
-        while True:
-            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)
-                    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)
-
-                    if (output and output[-1] != "\n") or (
-                        self.output[process.id]
-                        and self.output[process.id][-1][-1] != "\n"
-                    ):
-                        output += "\n"
-
-                    output += self._get_command_status(
-                        process,
-                        passed=process.return_code() == 0,
-                        timer=self.timer,
-                    )
-                    output += f"\n{self.colours.dim_on}=>{self.colours.dim_off} \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"{self.colours.dim_on}=>{self.colours.dim_off} \n{self.colours.dim_on}=>{self.colours.dim_off} {self.colours.yellow_bold}Interrupt!{self.colours.reset_colour}\n{self.colours.dim_on}=>{self.colours.dim_off} \n"
-                    interrupted = True
-
-            if output:
-                print(output, end="", flush=True)
-
-            if len(self.completed_processes) == len(self.processes):
-                break
-
-            time.sleep(0.01)
-
-        if self.interrupt_count == 2:
-            print(
-                f"{self.colours.dim_on}=>{self.colours.dim_off} {self.colours.red_bold}Abort!{self.colours.reset_colour}",
-                flush=True,
-            )
-
-        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,
-        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.dim_on}=>{self.colours.dim_off} {self.colours.white_bold}[{self.colours.reset_colour}{self.colours.blue_bold}{process.command}{self.colours.reset_colour}{self.colours.white_bold}]{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) -> 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 | None = None,
-        interactive: bool = False,
-        timer: bool = False,
-    ) -> ProcessGroup:
-        colours = colours or Colours()
-        processes: list[Process] = []
-        errors: list[InvalidExecutableError] = []
-
-        for i, command in enumerate(commands):
-            try:
-                processes.append(Process(i + 1, command))
-            except InvalidExecutableError as e:
-                errors.append(e)
-
-        if errors:
-            raise InvalidExecutableErrors(*errors)
-
-        process_group = cls(
-            processes=processes,
-            interactive=interactive,
-            timer=timer,
-            colours=colours,
-        )
-
-        return process_group
-
-    def complete_output(self, all: bool = False) -> str:
-        num_processes = len(self.processes)
-        lines = constants.LINES() - (2 * num_processes)
-        remainder = lines % num_processes
-        tail = lines // num_processes
-        for i in range(num_processes):
-            self.process_lines[i] = tail
-        if remainder:
-            self.process_lines[-1] += remainder - 2
-        else:
-            self.process_lines[-1] -= 2
-
-        output = ""
-        for i, process in enumerate(self.processes, start=1):
-            process_output = ""
-            if process.poll() is not None:
-                self.completed_processes.add(process.id)
-                if process.return_code() != 0:
-                    self.passed = False
-                process_output += self._get_command_status(
-                    process,
-                    passed=process.return_code() == 0,
-                    timer=self.timer,
-                )
-                process_output += "\n"
-            else:
-                process_output += self._get_command_status(
-                    process,
-                    icon=constants.ICONS[self.icon],
-                    timer=self.timer,
-                )
-                process_output += "\n"
-
-            command_lines = get_num_lines(process_output)
-            p_output = process.read().decode()
-            if not self.output[process.id]:
-                self.output[process.id].append("")
-            self.output[process.id][0] += p_output
-            p_output = self.output[process.id][0]
-            p_output_lines = 0
-            if p_output:
-                if not all:
-                    p_output = ""
-                    for line in p_output.splitlines()[-self.process_lines[i - 1] :]:
-                        if len(line) + 3 > constants.COLUMNS():
-                            p_output += f"{''.join(line[:constants.COLUMNS()-3])}\n"
-                        else:
-                            p_output += line + "\n"
-                p_output = self._prefix(p_output)
-                if p_output and p_output[-1] != "\n":
-                    p_output += "\n"
-                if i != num_processes:
-                    p_output += "\n"
-                p_output_lines = get_num_lines(p_output)
-
-            if not all and (command_lines + p_output_lines) > self.process_lines[i - 1]:
-                truncate = (command_lines + p_output_lines) - self.process_lines[i - 1]
-                p_output = "\n".join(p_output.splitlines()[truncate:])
-                p_output += "\n"
-
-            process_output += p_output
-            output += process_output
-
-        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

pyallel-1.2.5/src/pyallel/process_group_manager.py

@@ -1,95 +0,0 @@
-from __future__ import annotations
-
-import signal
-from dataclasses import dataclass, field
-from typing import Any
-
-from pyallel.colours import Colours
-from pyallel.process_group import ProcessGroup
-
-
-@dataclass
-class ProcessGroupManager:
-    process_groups: list[ProcessGroup]
-    interactive: bool = False
-    colours: Colours = field(default_factory=Colours)
-
-    def stream(self) -> int:
-        exit_code = 0
-
-        if not self.interactive:
-            print(
-                f"{self.colours.dim_on}=>{self.colours.dim_off} {self.colours.white_bold}Running commands...{self.colours.reset_colour}\n{self.colours.dim_on}=>{self.colours.dim_off} ",
-                flush=True,
-            )
-
-        for process_group in self.process_groups:
-            exit_code = process_group.stream()
-            if exit_code > 0:
-                break
-
-        return exit_code
-
-    def handle_signal(self, signum: int, _frame: Any) -> None:
-        for process_group in self.process_groups:
-            process_group.handle_signal(signum)
-
-    @classmethod
-    def from_args(
-        cls,
-        *args: str,
-        colours: Colours | None = None,
-        interactive: bool = False,
-        timer: bool = False,
-    ) -> ProcessGroupManager:
-        colours = colours or Colours()
-        last_separator_index = 0
-        commands: list[str] = []
-        process_groups: list[ProcessGroup] = []
-
-        for i, arg in enumerate(args):
-            if arg == ":::":
-                if i - 1 == 0:
-                    process_groups.append(
-                        ProcessGroup.from_commands(
-                            args[0],
-                            colours=colours,
-                            interactive=interactive,
-                            timer=timer,
-                        )
-                    )
-                else:
-                    process_groups.append(
-                        ProcessGroup.from_commands(
-                            *commands[last_separator_index:],
-                            colours=colours,
-                            interactive=interactive,
-                            timer=timer,
-                        )
-                    )
-
-                last_separator_index = i
-                continue
-
-            commands.append(arg)
-
-        if len(process_groups) > 1:
-            last_separator_index -= 1
-
-        process_groups.append(
-            ProcessGroup.from_commands(
-                *commands[last_separator_index:],
-                colours=colours,
-                interactive=interactive,
-                timer=timer,
-            )
-        )
-
-        process_group_manager = cls(
-            process_groups=process_groups, interactive=interactive, colours=colours
-        )
-
-        signal.signal(signal.SIGINT, process_group_manager.handle_signal)
-        signal.signal(signal.SIGTERM, process_group_manager.handle_signal)
-
-        return process_group_manager