pyallel 2.0.5__tar.gz → 2.0.6__tar.gz

{pyallel-2.0.5 → pyallel-2.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyallel
-Version: 2.0.5
+Version: 2.0.6
 Summary: Run and handle the output of multiple executables in pyallel (as in parallel)
 Project-URL: Homepage, https://github.com/Danthewaann/pyallel
 Project-URL: Repository, https://github.com/Danthewaann/pyallel

{pyallel-2.0.5 → pyallel-2.0.6}/benchmark_process.py

@@ -1,6 +1,4 @@
-"""
-Ad-hoc benchmark comparing Process's stdout reading approach against two
-scenarios:
+"""Ad-hoc benchmark comparing Process's stdout reading approach against two scenarios.
 
 1. A chatty command that produces a lot of output while it's running.
 2. A quick command that exits almost immediately, followed by a period of
@@ -26,9 +24,7 @@ def cpu_time() -> float:
     return usage.ru_utime + usage.ru_stime
 
 
-def run_scenario(
-    name: str, command: str, poll_seconds: float, extra_idle_seconds: float
-) -> None:
+def run_scenario(name: str, command: str, poll_seconds: float, extra_idle_seconds: float) -> None:
     process = Process(1, command)
 
     start_wall = time.perf_counter()
@@ -49,10 +45,7 @@ def run_scenario(
     end_wall = time.perf_counter()
     end_cpu = cpu_time()
 
-    print(
-        f"{name:12} wall={end_wall - start_wall:6.3f}s  "
-        f"cpu={end_cpu - start_cpu:6.3f}s  bytes={total_bytes}"
-    )
+    print(f"{name:12} wall={end_wall - start_wall:6.3f}s  cpu={end_cpu - start_cpu:6.3f}s  bytes={total_bytes}")
 
 
 def main() -> None:

pyallel-2.0.6/pyproject.toml

@@ -0,0 +1,133 @@
+[project]
+name = "pyallel"
+version = "2.0.6"
+description = "Run and handle the output of multiple executables in pyallel (as in parallel)"
+authors = [{ name = "Daniel Black", email = "danielcrblack@gmail.com" }]
+requires-python = ">=3.8"
+readme = "README.md"
+license = "MIT"
+keywords = [
+    "parallel",
+    "command",
+    "runner",
+    "executable",
+    "shell",
+    "terminal",
+]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: MacOS :: MacOS X",
+    "Operating System :: POSIX :: Linux",
+]
+
+[project.urls]
+Homepage = "https://github.com/Danthewaann/pyallel"
+Repository = "https://github.com/Danthewaann/pyallel"
+
+[project.scripts]
+pyallel = "pyallel.main:entry_point"
+
+[dependency-groups]
+dev = [
+    "pytest>=7.4.3,<8",
+    "mypy>=1.7.0,<2",
+    "pyinstaller==6.11.0",
+    "ruff>=0.15.20",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.mypy]
+strict = true
+show_error_codes = true
+
+[tool.pytest.ini_options]
+addopts = "-vvv"
+
+[tool.ruff]
+# Allow lines to be as long as 120 columns
+line-length = 120
+
+[tool.ruff.lint]
+# Ruff linting rules are listed within: https://beta.ruff.rs/docs/rules
+#
+# Globally enable all rules by default. We ignore ones we don't want below
+select = [
+    "ALL"
+]
+# Rules to ignore globally
+ignore = [
+    "ANN401",  # Dynamically typed expressions (typing.Any) are disallowed
+    "BLE001",  # Do not catch blind exceptions
+    "B904",    # Within an except* clause, raise exceptions with raise ... from err or raise ... from None
+    "COM812",  # Trailing comma missing
+    "COM819",  # Trailing comma prohibited
+    "D1",      # pydocstyle: undocumented code
+    "D203",    # pydocstyle: 1 blank line required before class docstring
+    "D213",    # pydocstyle: Multi-line docstring summary should start at the second line
+    "D401",    # pydocstyle: First line of docstring should be in imperative mood
+    "D413",    # pydocstyle: Missing blank line after last section
+    "E501",    # Line too long
+    "EM",      # flake8-errmsg: https://docs.astral.sh/ruff/rules/#flake8-errmsg-em
+    "FIX002",  # Line contains TODO, consider resolving the issue
+    "PLR0912", # Too many branches
+    "S106",    # Possible hardcoded password assigned to argument
+    "S603",    # subprocess call: check for execution of untrusted input
+    "S604",    # Function call with shell=True parameter identified, security issue
+    "T20",     # flake8-print: https://docs.astral.sh/ruff/rules/#flake8-print-t20
+    "TD002",   # Missing author in TODO
+    "TRY003",  # Avoid specifying long messages outside the exception class
+    "TRY201",  # Use raise without specifying exception name
+    "TRY400",  # Use logging.exception instead of logging.error
+    "PLR0913", # Too many arguments in function definition (> 5)
+]
+
+# Rules to ignore on a per file basis
+[tool.ruff.lint.per-file-ignores]
+"**/{tests}/*" = [
+    "D",       # ignore pydocstyle docstring rules in tests
+    "FBT",     # flake8-boolean-trap: https://docs.astral.sh/ruff/rules/#flake8-boolean-trap-fbt
+    "INP001",  # File is part of an implicit namespace package. Add an __init__.py
+    "N801",    # Class name should use CapWords convention
+    "PLR0913", # Too many arguments in function definition
+    "PLR2004", # Magic value used in comparison, consider replacing with a constant variable
+    "PT019",   # Fixture without value is injected as parameter, use @pytest.mark.usefixtures instead
+    "S101",    # Use of assert detected
+    "S104",    # Possible binding to all interfaces
+    "SLF001",  # Private member accessed
+    "S108",    # Probable insecure usage of temporary file or directory
+    "S607",    # Starting a process with a partial executable path
+]
+
+# Linter plugin configurations
+#
+# From: https://docs.astral.sh/ruff/settings
+[tool.ruff.lint.flake8-tidy-imports]
+# Disallow all relative imports.
+ban-relative-imports = "all"
+
+[tool.ruff.lint.isort]
+combine-as-imports = true
+force-wrap-aliases = true
+known-first-party = ["pizzabox", "tests"]
+
+[tool.ruff.lint.mccabe]
+# The maximum function complexity to allow before triggering C901 errors
+max-complexity = 20
+
+# Configure the ruff formatter
+[tool.ruff.format]
+# Like Black, use double quotes for strings
+quote-style = "double"
+# Like Black, indent with spaces, rather than tabs
+indent-style = "space"
+# Like Black, respect magic trailing commas
+skip-magic-trailing-comma = false
+# Like Black, automatically detect the appropriate line ending
+line-ending = "auto"
+# Enable reformatting of code snippets in docstrings
+docstring-code-format = true

{pyallel-2.0.5 → pyallel-2.0.6}/src/pyallel/colours.py

@@ -21,7 +21,7 @@ class Colours:
     def from_colour(cls, colour: Literal["yes", "no", "auto"]) -> Colours:
         colours = cls()
 
-        if colour == "no" or colour == "auto" and not constants.IN_TTY:
+        if colour == "no" or (colour == "auto" and not constants.IN_TTY):
             for field in fields(colours):
                 setattr(colours, field.name, "")
 

{pyallel-2.0.5 → pyallel-2.0.6}/src/pyallel/constants.py

@@ -12,18 +12,18 @@ ANSI_ESCAPE = re.compile(r"(\x9B|\x1B\[|\x1B\()[0-?]*[ -\/]*[@-~]")
 
 if IN_TTY:
 
-    def COLUMNS() -> int:
+    def columns() -> int:
         return shutil.get_terminal_size().columns
 
-    def LINES() -> int:
+    def lines() -> int:
         return shutil.get_terminal_size().lines
 
 else:
 
-    def COLUMNS() -> int:
+    def columns() -> int:
         return sys.maxsize
 
-    def LINES() -> int:
+    def lines() -> int:
         return sys.maxsize
 
 

{pyallel-2.0.5 → pyallel-2.0.6}/src/pyallel/errors.py

@@ -1,10 +1,10 @@
 class PyallelError(Exception):
-    """Base error for issues raised by pyallel"""
+    """Base error for issues raised by pyallel."""
 
 
 class InvalidLinesModifierError(PyallelError):
-    """Raised when the lines modifier is invalid"""
+    """Raised when the lines modifier is invalid."""
 
 
 class NoCommandsForProcessGroupError(PyallelError):
-    """Raised when no commands have been provided for a process group"""
+    """Raised when no commands have been provided for a process group."""

{pyallel-2.0.5 → pyallel-2.0.6}/src/pyallel/main.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import importlib.metadata
+import logging
 import sys
 import time
 import traceback
@@ -16,6 +17,15 @@ from pyallel.printer import (
 )
 from pyallel.process_group_manager import ProcessGroupManager
 
+logging.basicConfig(
+    filename="pyallel.log",
+    format="%(asctime)s:%(levelname)s:%(name)s:%(lineno)d[%(threadName)s]:%(message)s",
+    datefmt="%Y-%m-%dT%H:%M:%S",
+    level=logging.DEBUG,
+)
+
+logger = logging.getLogger(__name__)
+
 
 def entry_point(*args: str) -> int:
     args = args or tuple(sys.argv[1:])
@@ -41,28 +51,22 @@ def entry_point(*args: str) -> int:
     try:
         process_group_manager = ProcessGroupManager.from_args(*parsed_args.commands)
     except PyallelError as e:
-        print(f"{colours.red_bold}Error: {str(e)}{colours.reset_colour}")
+        print(f"{colours.red_bold}Error: {e!s}{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}"
-        )
+        print(f"{colours.red_bold}Error: {traceback.format_exc()}{colours.reset_colour}")
         return 1
 
     if exit_code == 1:
         process_group = process_group_manager.get_cur_process_group_output()
-        print(
-            f"\n{colours.red_bold}ERROR: the following commands failed{colours.reset_colour}"
-        )
+        print(f"\n{colours.red_bold}ERROR: the following commands failed{colours.reset_colour}")
         for process_output in process_group.processes:
             process_poll = process_output.process.poll()
             if process_poll and process_poll > 0:
-                print(
-                    f"   {colours.red_bold}{process_output.process.command}{colours.reset_colour}"
-                )
+                print(f"   {colours.red_bold}{process_output.process.command}{colours.reset_colour}")
 
     return exit_code
 
@@ -77,7 +81,8 @@ def run(process_group_manager: ProcessGroupManager, printer: Printer) -> int:
         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():
+            has_output = process_group_manager.stream().has_output()
+            if has_output:
                 printer.print(process_group_manager)
 
             if poll > 0:

{pyallel-2.0.5 → pyallel-2.0.6}/src/pyallel/parser.py

@@ -24,11 +24,11 @@ DESCRIPTION = r"""run and handle the output of multiple executables in %(prog)s
 RUNNING COMMANDS
 ================
 to run multiple commands you must separate them using the command separator symbol (::)
-    
+
   %(prog)s mypy . :: black .
 
-if you want to provide options to a command you need to use the double dash symbol (--) to indicate that 
-any options provided after this symbol should not be interpreted by %(prog)s 
+if you want to provide options to a command you need to use the double dash symbol (--) to indicate that
+any options provided after this symbol should not be interpreted by %(prog)s
 
   %(prog)s -n -- mypy -V :: black --version
 
@@ -45,7 +45,7 @@ modifiers can also be set for commands to augment their behaviour using the comm
 
 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
@@ -54,7 +54,7 @@ SHELL SYNTAX
 ============
 each command is executed inside its own shell, this means shell syntax is supported.
 it is important to note that certain shell syntax must be escaped using backslashes (\)
-or wrapped in single quotes (''), otherwise it will be evaluated in your current 
+or wrapped in single quotes (''), otherwise it will be evaluated in your current
 shell immediately instead of the shell that your command will run within.
 
 some examples of using shell syntax are below (single quotes are used only if required)

{pyallel-2.0.5 → pyallel-2.0.6}/src/pyallel/printer.py

@@ -1,13 +1,15 @@
 from __future__ import annotations
 
 import time
-from typing import Protocol
+from typing import TYPE_CHECKING, Protocol
 
 from pyallel import constants
 from pyallel.colours import Colours
-from pyallel.process import Process, ProcessOutput
-from pyallel.process_group import ProcessGroupOutput
-from pyallel.process_group_manager import ProcessGroupManager
+
+if TYPE_CHECKING:
+    from pyallel.process import Process, ProcessOutput
+    from pyallel.process_group import ProcessGroupOutput
+    from pyallel.process_group_manager import ProcessGroupManager
 
 
 class Printer(Protocol):
@@ -20,7 +22,7 @@ class Printer(Protocol):
 
 
 class ConsolePrinter:
-    def __init__(self, colours: Colours | None = None, timer: bool = False) -> None:
+    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} "
@@ -30,6 +32,7 @@ class ConsolePrinter:
     def write(
         self,
         line: str,
+        *,
         include_prefix: bool = False,
         end: str = "\n",
         flush: bool = False,
@@ -38,7 +41,7 @@ class ConsolePrinter:
     ) -> None:
         truncate_num = 0
         prefix = self._prefix if include_prefix else ""
-        columns = columns or constants.COLUMNS()
+        columns = columns or constants.columns()
         if prefix:
             truncate_num = 6
         if prefix and truncate:
@@ -50,6 +53,7 @@ class ConsolePrinter:
     def generate_process_output(
         self,
         output: ProcessOutput,
+        *,
         tail_output: bool = False,
         include_cmd: bool = True,
         include_output: bool = True,
@@ -65,7 +69,7 @@ class ConsolePrinter:
 
         if include_cmd:
             status = self.generate_process_output_status(
-                output, include_progress, include_timer
+                output, include_progress=include_progress, include_timer=include_timer
             )
             line_parts = (False, status, "\n")
             out.append(line_parts)
@@ -76,10 +80,7 @@ class ConsolePrinter:
 
             if tail_output:
                 output_lines = output.process.lines - 1
-                if output_lines == 0:
-                    lines = []
-                else:
-                    lines = lines[-output_lines:]
+                lines = [] if output_lines == 0 else lines[-output_lines:]
 
             for line in lines:
                 prefix = True
@@ -87,7 +88,7 @@ class ConsolePrinter:
                 if append_newlines and end != "\n":
                     end = "\n"
                 else:
-                    line = line[:-1]
+                    line = line[:-1]  # noqa: PLW2901
 
                 try:
                     prev_line = self._to_print[-1]
@@ -106,12 +107,13 @@ class ConsolePrinter:
     def generate_process_output_status(
         self,
         output: ProcessOutput,
+        *,
         include_progress: bool = True,
         include_timer: bool | None = None,
         columns: int | None = None,
     ) -> str:
         include_timer = include_timer if include_timer is not None else self._timer
-        columns = columns or constants.COLUMNS()
+        columns = columns or constants.columns()
 
         passed = None
         icon = ""
@@ -159,13 +161,14 @@ class ConsolePrinter:
     def generate_process_group_output(
         self,
         output: ProcessGroupOutput,
+        *,
         interrupt_count: int = 0,
         tail_output: bool = True,
     ) -> list[tuple[bool, str, str]]:
         self.set_process_lines(output, interrupt_count)
 
         for out in output.processes:
-            self.generate_process_output(out, tail_output, append_newlines=True)
+            self.generate_process_output(out, tail_output=tail_output, append_newlines=True)
 
         if interrupt_count == 1:
             self._to_print.append((False, "", "\n"))
@@ -176,7 +179,7 @@ class ConsolePrinter:
                     "\n",
                 )
             )
-        elif interrupt_count == 2:
+        elif interrupt_count == 2:  # noqa: PLR2004
             self._to_print.append((False, "", "\n"))
             self._to_print.append(
                 (
@@ -198,7 +201,7 @@ class ConsolePrinter:
         interrupt_count: int = 0,
         lines: int = 0,
     ) -> None:
-        lines = lines or constants.LINES() - 1
+        lines = lines or constants.lines() - 1
         if interrupt_count:
             lines -= 2
 
@@ -212,9 +215,7 @@ class ConsolePrinter:
                 processes_with_dynamic_lines.append(process_output)
                 continue
 
-            process_output.process.lines = int(
-                lines * process_output.process.percentage_lines
-            )
+            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
@@ -269,7 +270,7 @@ class ConsolePrinter:
 
     def get_num_lines(self, line: str, columns: int | None = None) -> int:
         lines = 0
-        columns = columns or constants.COLUMNS()
+        columns = columns or constants.columns()
         line = constants.ANSI_ESCAPE.sub("", line)
         length = len(line)
         line_lines = 1
@@ -282,7 +283,7 @@ class ConsolePrinter:
         return lines
 
     def truncate_line(self, line: str, columns: int | None = None) -> str:
-        columns = columns or constants.COLUMNS()
+        columns = columns or constants.columns()
         escaped_line = constants.ANSI_ESCAPE.sub("", line)
         return "".join(escaped_line[:columns]) + "..."
 
@@ -294,31 +295,32 @@ class ConsolePrinter:
 
 
 class InteractiveConsolePrinter(ConsolePrinter):
-    def __init__(self, colours: Colours | None = None, timer: bool = False) -> None:
-        super().__init__(colours, timer)
+    def __init__(self, colours: Colours | None = None, *, timer: bool = False) -> None:
+        super().__init__(colours, timer=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_process_group_output(output, process_group_manager._interrupt_count)
+        self.print_process_group_output(output, interrupt_count=process_group_manager.interrupt_count)
 
         poll = process_group_manager.poll()
         if poll is not None:
             self.clear_last_printed_lines()
             self.reset()
             self.print_process_group_output(
-                output, process_group_manager._interrupt_count, tail_output=False
+                output, interrupt_count=process_group_manager.interrupt_count, tail_output=False
             )
             self.reset()
 
     def print_process_group_output(
         self,
         output: ProcessGroupOutput,
+        *,
         interrupt_count: int = 0,
         tail_output: bool = True,
     ) -> None:
-        columns = constants.COLUMNS()
-        self.generate_process_group_output(output, interrupt_count, tail_output)
+        columns = constants.columns()
+        self.generate_process_group_output(output, interrupt_count=interrupt_count, tail_output=tail_output)
 
         num_lines_to_print = len(self._to_print)
         num_last_printed_lines = len(self._last_printed)
@@ -327,9 +329,7 @@ class InteractiveConsolePrinter(ConsolePrinter):
         # we just print all the new lines
         if not num_last_printed_lines or not tail_output:
             for include_prefix, line, end in self._to_print:
-                self.write(
-                    line, include_prefix, end, truncate=tail_output, columns=columns
-                )
+                self.write(line, include_prefix=include_prefix, end=end, truncate=tail_output, columns=columns)
         else:
             # Compare the number of last lines and new lines and only update what has changed.
             #
@@ -337,9 +337,7 @@ class InteractiveConsolePrinter(ConsolePrinter):
             # comparing the last printed lines with the new lines that were generated
             print(f"\033[{num_last_printed_lines}A", end="")
             cursor_line = 0
-            for cur_line, line_parts in enumerate(
-                self._last_printed[:num_lines_to_print]
-            ):
+            for cur_line, line_parts in enumerate(self._last_printed[:num_lines_to_print]):
                 # If the current line is not the same as it's newly generated version, we update the line
                 if line_parts[1] != self._to_print[cur_line][1]:
                     include_prefix, line, end = self._to_print[cur_line]
@@ -350,9 +348,7 @@ class InteractiveConsolePrinter(ConsolePrinter):
                     # Clear the current line
                     print(f"{constants.CLEAR_LINE}\r", end="")
                     # Write the new line, this will move the cursor to the next line automatically
-                    self.write(
-                        line, include_prefix, end, truncate=tail_output, columns=columns
-                    )
+                    self.write(line, include_prefix=include_prefix, end=end, truncate=tail_output, columns=columns)
                     # Need to set the cursor_line to be the current line + 1 as the above write
                     # will move the cursor to the next line
                     cursor_line = cur_line + 1
@@ -366,17 +362,18 @@ class InteractiveConsolePrinter(ConsolePrinter):
                 # Just print the new lines as normal
                 for line_parts in self._to_print[num_last_printed_lines:]:
                     include_prefix, line, end = line_parts
-                    self.write(
-                        line, include_prefix, end, truncate=tail_output, columns=columns
-                    )
+                    self.write(line, include_prefix=include_prefix, end=end, truncate=tail_output, columns=columns)
+            elif num_last_printed_lines > num_lines_to_print:
+                # Make sure to clear the remaining last printed lines at the end of the screen so they don't get left behind
+                print("\033[0J", end="")
             else:
-                # Jump to the end of the output
+                # Jump to the end of the output since the num of lines printed hasn't changed
                 lines_to_jump = num_lines_to_print - cursor_line
                 if lines_to_jump:
                     print(f"\033[{lines_to_jump}B\r", end="")
 
             # Force a flush to return the cursor to the bottom immediately
-            print("", end="", flush=True)
+            print(end="", flush=True)
 
         self._last_printed = self._to_print.copy()
         self._to_print.clear()
@@ -384,8 +381,7 @@ class InteractiveConsolePrinter(ConsolePrinter):
     def clear_last_printed_lines(self) -> None:
         # Clear all the lines that were just printed
         print(
-            f"{constants.CLEAR_LINE}{constants.UP_LINE}{constants.CLEAR_LINE}"
-            * len(self._last_printed),
+            f"{constants.CLEAR_LINE}{constants.UP_LINE}{constants.CLEAR_LINE}" * len(self._last_printed),
             end="",
         )
 
@@ -395,8 +391,8 @@ class InteractiveConsolePrinter(ConsolePrinter):
 
 
 class NonInteractiveConsolePrinter(ConsolePrinter):
-    def __init__(self, colours: Colours | None = None, timer: bool = False) -> None:
-        super().__init__(colours, timer)
+    def __init__(self, colours: Colours | None = None, *, timer: bool = False) -> None:
+        super().__init__(colours, timer=timer)
         self._current_process: Process | None = None
 
     def print(self, process_group_manager: ProcessGroupManager) -> None:
@@ -405,10 +401,8 @@ class NonInteractiveConsolePrinter(ConsolePrinter):
             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
-                    )
+                    process_output = process_group_manager.get_process(output.id)
+                    self.print_process_output(process_output, include_progress=False, include_timer=False)
                 elif self._current_process is not output.process:
                     continue
                 else:
@@ -421,6 +415,7 @@ class NonInteractiveConsolePrinter(ConsolePrinter):
     def print_process_output(
         self,
         output: ProcessOutput,
+        *,
         tail_output: bool = False,
         include_cmd: bool = True,
         include_output: bool = True,
@@ -429,13 +424,13 @@ class NonInteractiveConsolePrinter(ConsolePrinter):
     ) -> None:
         for include_prefix, line, end in self.generate_process_output(
             output,
-            tail_output,
-            include_cmd,
-            include_output,
-            include_progress,
-            include_timer,
+            tail_output=tail_output,
+            include_cmd=include_cmd,
+            include_output=include_output,
+            include_progress=include_progress,
+            include_timer=include_timer,
         ):
-            self.write(line, include_prefix, end)
+            self.write(line, include_prefix=include_prefix, end=end)
 
         # 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)
+        print(end="", flush=True)