pyallel 1.2.7__tar.gz → 1.3.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyallel
-Version: 1.2.7
+Version: 1.3.0
 Summary: Run and handle the output of multiple executables in pyallel (as in parallel)
 Home-page: https://github.com/Danthewaann/pyallel
 License: MIT
@@ -62,15 +62,28 @@ positional arguments:
                              "echo \$SHELL" or "\$(echo mypy .)"  <- expand variables and commands to evaluate (must be escaped)
                              "pytest . && mypy . || echo failed!" <- use AND (&&) and OR (||) to run commands conditionally
 
+                        PROCESS GROUPS
+                        --------------
                         commands can be grouped using the group separator symbol (:::)
 
-                             "echo boil kettle" "sleep 1" ::: "echo make coffee"
+                             %(prog)s "echo boil kettle" "sleep 1" ::: "echo make coffee"
 
                         the above will print "boil kettle" and sleep for 1 second first before printing "make coffee"
 
                         command groups are ran in the sequence you provide them, and if a command group fails
                         (if a command fails inside the command group) the rest of the command groups in the sequence are not run
 
+                        COMMAND MODIFIERS
+                        -----------------
+                        modifiers can be set for commands to augment their behaviour using the command modifier symbol (::)
+
+                        lines (only used in interactive mode):
+                            the lines modifier allows you to specify how many lines the command output can take up on the screen
+        
+                                %(prog)s "lines=90 :: echo running long command..." "echo running other command..."
+
+                            90 is expressed as a percentage value, which must be between 1 and 100 inclusive
+
 options:
   -h, --help            show this help message and exit
   -t, --no-timer        don't time how long each command is taking
@@ -142,8 +155,8 @@ python -m venv .venv && \
 
 - [x] Add support to have commands depend on other commands (some commands must complete
       before a given command can start)
+- [x] Add support to state how many lines a command can use for it's output in interactive mode
 - [ ] Add a debug mode that logs debug information to a log file
-- [ ] Add support to state how many lines a command can use for it's output in interactive mode
 - [ ] Maybe add support to allow the user to provide stdin for commands that request it
       (such as a REPL)
 - [ ] Add custom parsing of command output to support filtering for errors (like vim's

{pyallel-1.2.7 → pyallel-1.3.0}/README.md

@@ -38,15 +38,28 @@ positional arguments:
                              "echo \$SHELL" or "\$(echo mypy .)"  <- expand variables and commands to evaluate (must be escaped)
                              "pytest . && mypy . || echo failed!" <- use AND (&&) and OR (||) to run commands conditionally
 
+                        PROCESS GROUPS
+                        --------------
                         commands can be grouped using the group separator symbol (:::)
 
-                             "echo boil kettle" "sleep 1" ::: "echo make coffee"
+                             %(prog)s "echo boil kettle" "sleep 1" ::: "echo make coffee"
 
                         the above will print "boil kettle" and sleep for 1 second first before printing "make coffee"
 
                         command groups are ran in the sequence you provide them, and if a command group fails
                         (if a command fails inside the command group) the rest of the command groups in the sequence are not run
 
+                        COMMAND MODIFIERS
+                        -----------------
+                        modifiers can be set for commands to augment their behaviour using the command modifier symbol (::)
+
+                        lines (only used in interactive mode):
+                            the lines modifier allows you to specify how many lines the command output can take up on the screen
+        
+                                %(prog)s "lines=90 :: echo running long command..." "echo running other command..."
+
+                            90 is expressed as a percentage value, which must be between 1 and 100 inclusive
+
 options:
   -h, --help            show this help message and exit
   -t, --no-timer        don't time how long each command is taking
@@ -118,8 +131,8 @@ python -m venv .venv && \
 
 - [x] Add support to have commands depend on other commands (some commands must complete
       before a given command can start)
+- [x] Add support to state how many lines a command can use for it's output in interactive mode
 - [ ] Add a debug mode that logs debug information to a log file
-- [ ] Add support to state how many lines a command can use for it's output in interactive mode
 - [ ] Maybe add support to allow the user to provide stdin for commands that request it
       (such as a REPL)
 - [ ] Add custom parsing of command output to support filtering for errors (like vim's

{pyallel-1.2.7 → pyallel-1.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pyallel"
-version = "1.2.7"
+version = "1.3.0"
 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.0/src/pyallel/errors.py

@@ -0,0 +1,2 @@
+class InvalidLinesModifierError(Exception):
+    """Raised when the lines modifier is invalid"""

{pyallel-1.2.7 → pyallel-1.3.0}/src/pyallel/main.py

@@ -7,7 +7,7 @@ import time
 
 from pyallel import constants
 from pyallel.colours import Colours
-from pyallel.errors import InvalidExecutableErrors
+from pyallel.errors import InvalidLinesModifierError
 from pyallel.parser import Arguments, create_parser
 from pyallel.printer import Printer
 from pyallel.process_group_manager import ProcessGroupManager
@@ -111,7 +111,7 @@ def run(*args: str) -> int:
             exit_code = run_interactive(process_group_manager, printer)
         else:
             exit_code = run_non_interactive(process_group_manager, printer)
-    except InvalidExecutableErrors as e:
+    except InvalidLinesModifierError as e:
         exit_code = 1
         message = str(e)
     except Exception:

{pyallel-1.2.7 → pyallel-1.3.0}/src/pyallel/parser.py

@@ -31,14 +31,27 @@ if you were running the command directly in a shell, some examples are below
      "echo \$SHELL" or "\$(echo mypy .)"  <- expand variables and commands to evaluate (must be escaped)
      "pytest . && mypy . || echo failed!" <- use AND (&&) and OR (||) to run commands conditionally
 
+PROCESS GROUPS
+--------------
 commands can be grouped using the group separator symbol (:::)
 
-     "echo boil kettle" "sleep 1" ::: "echo make coffee"
+     %(prog)s "echo boil kettle" "sleep 1" ::: "echo make coffee"
 
 the above will print "boil kettle" and sleep for 1 second first before printing "make coffee"
 
 command groups are ran in the sequence you provide them, and if a command group fails
 (if a command fails inside the command group) the rest of the command groups in the sequence are not run
+
+COMMAND MODIFIERS
+-----------------
+modifiers can be set for commands to augment their behaviour using the command modifier symbol (::)
+
+lines (only used in interactive mode):
+    the lines modifier allows you to specify how many lines the command output can take up on the screen
+        
+        %(prog)s "lines=90 :: echo running long command..." "echo running other command..."
+
+    90 is expressed as a percentage value, which must be between 1 and 100 inclusive
 """
 
 

{pyallel-1.2.7 → pyallel-1.3.0}/src/pyallel/printer.py

@@ -21,14 +21,18 @@ class Printer:
         line: str,
         include_prefix: bool = False,
         end: str = "\n",
+        flush: bool = False,
         truncate: bool = False,
     ) -> None:
+        truncate_num = 0
         prefix = self._prefix if include_prefix else ""
+        if prefix:
+            truncate_num = 6
         if truncate:
-            columns = constants.COLUMNS() - len(prefix)
+            columns = constants.COLUMNS() - truncate_num
             if get_num_lines(line, columns) > 1:
                 line = truncate_line(line, columns)
-        print(f"{prefix}{line}", end=end, flush=True)
+        print(f"{prefix}{line}", end=end, flush=flush)
 
     def info(self, msg: str) -> None:
         self.write(
@@ -67,6 +71,9 @@ class Printer:
         out: list[tuple[bool, str, str]] = []
         line_parts: tuple[bool, str, str]
 
+        if tail_output and output.process.lines == 0:
+            return out
+
         if include_cmd:
             status = self.generate_process_output_status(
                 output, include_progress, include_timer
@@ -79,9 +86,11 @@ class Printer:
             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:]
+                output_lines = output.process.lines - 1
+                if output_lines == 0:
+                    lines = []
+                else:
+                    lines = lines[-output_lines:]
 
             for line in lines:
                 prefix = True
@@ -136,14 +145,23 @@ class Printer:
             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}"
-
+        timer = ""
         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}"
+            timer = f"({format_time_taken(elapsed)})"
+
+        command = output.process.command
+        if get_num_lines(output.process.command) > 1:
+            columns = constants.COLUMNS() - (len(msg) + len(timer) + 9)
+            command = 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}"
+
+        if timer:
+            out += f" {self._colours.dim_on}{timer}{self._colours.dim_off}"
 
         return out
 
@@ -202,6 +220,9 @@ class Printer:
         ):
             self.write(line, include_prefix, end)
 
+        # Force a flush otherwise lines that don't end in a newline character will not get printed as they are read
+        self.write("", include_prefix=False, end="", flush=True)
+
     def print_progress_group_output(
         self,
         output: ProcessGroupOutput,
@@ -231,20 +252,39 @@ class Printer:
 def set_process_lines(
     output: ProcessGroupOutput,
     interrupt_count: int = 0,
-    lines: int | None = None,
+    lines: int = 0,
 ) -> 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
-
+    # Allocate lines to processes that have a fixed percentage of lines set
+    used_lines = 0
+    other_processes: list[ProcessOutput] = []
     for out in output.processes:
-        out.lines = tail
-    if remainder:
-        output.processes[-1].lines += remainder
+        if not out.process.percentage_lines:
+            other_processes.append(out)
+            continue
+
+        out.process.lines = int(lines * out.process.percentage_lines)
+        used_lines += out.process.lines
+
+    lines -= used_lines
+
+    # Allocate the rest of the available lines to the other processes that don't have fixed lines set
+    num_dynamic_processes = len(other_processes)
+    if num_dynamic_processes:
+        remainder = lines % num_dynamic_processes
+        tail = lines // num_dynamic_processes
+
+        for out in other_processes:
+            out.process.lines = tail
+
+        # If we have lines left to allocate, we give all of them to the last process
+        if remainder:
+            for out in other_processes[-1::-1]:
+                out.process.lines += remainder
+                break
 
 
 def get_num_lines(line: str, columns: int | None = None) -> int:

{pyallel-1.2.7 → pyallel-1.3.0}/src/pyallel/process.py

@@ -6,24 +6,27 @@ import tempfile
 import time
 from typing import BinaryIO
 
+from pyallel.errors import InvalidLinesModifierError
+
 
 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:
+    def __init__(self, id: int, command: str, percentage_lines: float = 0.0) -> None:
         self.id = id
         self.command = command
         self.start = 0.0
         self.end = 0.0
+        self.lines = 0
+        self.percentage_lines = percentage_lines
         self._fd: BinaryIO
         self._process: subprocess.Popen[bytes]
 
@@ -71,3 +74,34 @@ class Process:
     def wait(self) -> int:
         return self._process.wait()
 
+    @classmethod
+    def from_command(cls, id: int, command: str) -> Process:
+        cmd = command.split(" :: ", maxsplit=1)
+        if len(cmd) == 1:
+            return cls(id, cmd[0])
+
+        args, *parts = cmd
+
+        percentage_lines = 0.0
+        for arg in args.split(" "):
+            try:
+                arg, value = args.split("=")
+            except ValueError:
+                continue
+
+            if arg == "lines":
+                try:
+                    percentage_lines = int(value) / 100
+                except ValueError:
+                    raise InvalidLinesModifierError(
+                        "lines modifier must be a number between 1 and 100"
+                    )
+
+                if not 0.0 < percentage_lines <= 1.0:
+                    raise InvalidLinesModifierError(
+                        "lines modifier must be a number between 1 and 100"
+                    )
+
+                break
+
+        return cls(id, " ".join(parts), percentage_lines)

{pyallel-1.2.7 → pyallel-1.3.0}/src/pyallel/process_group.py

@@ -2,7 +2,9 @@ from __future__ import annotations
 
 from typing import Sequence
 
-from pyallel.errors import InvalidExecutableError, InvalidExecutableErrors
+from pyallel.errors import (
+    InvalidLinesModifierError,
+)
 from pyallel.process import Process, ProcessOutput
 
 
@@ -63,16 +65,17 @@ class ProcessGroup:
     @classmethod
     def from_commands(cls, id: int, process_id: int, *commands: str) -> ProcessGroup:
         processes: list[Process] = []
-        errors: list[InvalidExecutableError] = []
 
+        percentage_lines_sum = 0.0
         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 = Process.from_command(i + process_id, command)
+            percentage_lines_sum += process.percentage_lines
+            processes.append(process)
+
+        if percentage_lines_sum > 1.0:
+            raise InvalidLinesModifierError(
+                "lines modifier must not exceed 100 across all processes within each process group"
+            )
 
         process_group = cls(id=id, processes=processes)
 

pyallel-1.2.7/src/pyallel/errors.py

@@ -1,11 +0,0 @@
-class InvalidExecutableError(Exception):
-    def __init__(self, exe: str) -> None:
-        super().__init__(exe)
-        self.exe = exe
-
-
-class InvalidExecutableErrors(Exception):
-    def __init__(self, *errors: InvalidExecutableError) -> None:
-        super().__init__(
-            f"executables [{', '.join(error.exe for error in errors)}] were not found"
-        )