pyallel 1.2.8__tar.gz → 1.3.1__tar.gz

{pyallel-1.2.8 → pyallel-1.3.1}/PKG-INFO

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

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

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

{pyallel-1.2.8 → pyallel-1.3.1}/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
@@ -35,7 +35,7 @@ def run_interactive(
             if poll > 0:
                 return poll
 
-            printer.clear()
+            printer.reset()
             process_group_manager.run()
             if not process_group_manager.next():
                 return 0
@@ -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.8 → pyallel-1.3.1}/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.8 → pyallel-1.3.1}/src/pyallel/printer.py

@@ -21,6 +21,7 @@ class Printer:
         line: str,
         include_prefix: bool = False,
         end: str = "\n",
+        flush: bool = False,
         truncate: bool = False,
     ) -> None:
         truncate_num = 0
@@ -31,7 +32,7 @@ class Printer:
             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(
@@ -70,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
@@ -82,8 +86,11 @@ class Printer:
             lines = output.data.splitlines(keepends=True)
 
             if tail_output:
-                output_lines = output.lines - 1
-                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
@@ -213,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,
@@ -233,29 +243,62 @@ class Printer:
                     end="",
                 )
 
-        self.clear()
+        self.reset()
 
-    def clear(self) -> None:
+    def reset(self) -> None:
         self._printed.clear()
 
 
 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
+    process_with_most_lines: ProcessOutput | None = None
+    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
+
+        if (
+            process_with_most_lines is None
+            or process_with_most_lines.process.lines < out.process.lines
+        ):
+            process_with_most_lines = out
+
+    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 process with the highest 
+        # allocated lines or to the last process
+        if remainder:
+            if process_with_most_lines:
+                process_with_most_lines.process.lines += remainder
+            else:
+                other_processes[-1].process.lines += remainder
+    else:
+        # Otherwise allocate remaining lines to the process with the highest allocated lines
+        remainder = lines
+        if remainder and process_with_most_lines:
+            process_with_most_lines.process.lines += remainder
 
 
 def get_num_lines(line: str, columns: int | None = None) -> int:

{pyallel-1.2.8 → pyallel-1.3.1}/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
+        for arg in args.split(" "):
+            try:
+                arg, value = args.split("=")
+            except ValueError:
+                continue
+
+            if arg == "lines":
+                try:
+                    percentage_lines = int(value)
+                except ValueError:
+                    raise InvalidLinesModifierError(
+                        "lines modifier must be a number between 1 and 100"
+                    )
+
+                if not 0 < percentage_lines <= 100:
+                    raise InvalidLinesModifierError(
+                        "lines modifier must be a number between 1 and 100"
+                    )
+
+                break
+
+        return cls(id, " ".join(parts), round(percentage_lines / 100, 2))

{pyallel-1.2.8 → pyallel-1.3.1}/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 round(percentage_lines_sum, 2) > 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.8/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"
-        )