pyallel 1.2.0__tar.gz → 1.2.2__tar.gz

{pyallel-1.2.0 → pyallel-1.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyallel
-Version: 1.2.0
+Version: 1.2.2
 Summary: Run and handle the output of multiple executables in pyallel (as in parallel)
 Home-page: https://github.com/Danthewaann/pyallel
 License: MIT
@@ -98,28 +98,49 @@ You can also build an executable with the following (executables will be written
 > The `arch=x86_64` values in the following code blocks can be replaced with `arch=aarch64` and
 > any other architecture that is supported by docker to build an executable for that given architecture
 
+> [!NOTE]
+> To build aarch64 binaries on an x86_64 host machine, you will need to run the following
+> commands to setup qemu to allow this to work
+
+```bash
+sudo apt-get install qemu binfmt-support qemu-user-static && \
+docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
+```
+
 #### Build for generic linux
 
 ```bash
-docker build --tag pyallel --build-arg 'arch=x86_64' . && docker run -e 'arch=x86_64' --rm --volume "$(pwd):/src" pyallel
+docker build --tag pyallel --build-arg 'arch=x86_64' --build-arg "uid=$(id -u)" . && \
+    docker run -e 'arch=x86_64' --rm --volume "$(pwd):/src" pyallel
 ```
 
 #### Build for alpine linux
 
 ```bash
-docker build --tag pyallel-alpine --build-arg 'arch=x86_64' --file Dockerfile.alpine . && docker run -e 'arch=x86_64' --rm --volume "$(pwd):/src" pyallel-alpine
+docker build --tag pyallel-alpine --build-arg 'arch=x86_64' --build-arg "uid=$(id -u)" --file Dockerfile.alpine . && \
+    docker run -e 'arch=x86_64' --rm --volume "$(pwd):/src" pyallel-alpine
 ```
 
 #### Build locally
 
 ```bash
-python -m venv .venv && source .venv/bin/activate && pip install . -r requirements_build.txt && ./build.sh
+python -m venv .venv && \
+  source .venv/bin/activate && \
+  pip install . -r requirements_build.txt && \
+  ./build.sh
+```
+
+#### Build all
+
+```bash
+./build_all.sh
 ```
 
 ## TODOs
 
 - [x] Add support to have commands depend on other commands (some commands must complete
       before a given command can start)
+- [ ] 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)

{pyallel-1.2.0 → pyallel-1.2.2}/README.md

@@ -76,28 +76,49 @@ You can also build an executable with the following (executables will be written
 > The `arch=x86_64` values in the following code blocks can be replaced with `arch=aarch64` and
 > any other architecture that is supported by docker to build an executable for that given architecture
 
+> [!NOTE]
+> To build aarch64 binaries on an x86_64 host machine, you will need to run the following
+> commands to setup qemu to allow this to work
+
+```bash
+sudo apt-get install qemu binfmt-support qemu-user-static && \
+docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
+```
+
 #### Build for generic linux
 
 ```bash
-docker build --tag pyallel --build-arg 'arch=x86_64' . && docker run -e 'arch=x86_64' --rm --volume "$(pwd):/src" pyallel
+docker build --tag pyallel --build-arg 'arch=x86_64' --build-arg "uid=$(id -u)" . && \
+    docker run -e 'arch=x86_64' --rm --volume "$(pwd):/src" pyallel
 ```
 
 #### Build for alpine linux
 
 ```bash
-docker build --tag pyallel-alpine --build-arg 'arch=x86_64' --file Dockerfile.alpine . && docker run -e 'arch=x86_64' --rm --volume "$(pwd):/src" pyallel-alpine
+docker build --tag pyallel-alpine --build-arg 'arch=x86_64' --build-arg "uid=$(id -u)" --file Dockerfile.alpine . && \
+    docker run -e 'arch=x86_64' --rm --volume "$(pwd):/src" pyallel-alpine
 ```
 
 #### Build locally
 
 ```bash
-python -m venv .venv && source .venv/bin/activate && pip install . -r requirements_build.txt && ./build.sh
+python -m venv .venv && \
+  source .venv/bin/activate && \
+  pip install . -r requirements_build.txt && \
+  ./build.sh
+```
+
+#### Build all
+
+```bash
+./build_all.sh
 ```
 
 ## TODOs
 
 - [x] Add support to have commands depend on other commands (some commands must complete
       before a given command can start)
+- [ ] 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)

{pyallel-1.2.0 → pyallel-1.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pyallel"
-version = "1.2.0"
+version = "1.2.2"
 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.0 → pyallel-1.2.2}/src/pyallel/constants.py

@@ -5,7 +5,7 @@ import sys
 IN_TTY = sys.stdout.isatty()
 CLEAR_LINE = "\033[2K"
 UP_LINE = "\033[1F"
-ANSI_ESCAPE = re.compile(r"(\x9B|\x1B\[)[0-?]*[ -\/]*[@-~]")
+ANSI_ESCAPE = re.compile(r"(\x9B|\x1B\[|\x1B\()[0-?]*[ -\/]*[@-~]")
 
 if IN_TTY:
 

{pyallel-1.2.0 → pyallel-1.2.2}/src/pyallel/process.py

@@ -70,7 +70,3 @@ class Process:
         if self._process:
             return self._process.wait()
         return -1
-
-    @classmethod
-    def from_command(cls, id: int, command: str) -> Process:
-        return cls(id=id, command=command)

{pyallel-1.2.0 → pyallel-1.2.2}/src/pyallel/process_group.py

@@ -16,7 +16,13 @@ def get_num_lines(output: str, columns: int | None = None) -> int:
     for line in output.splitlines():
         line = constants.ANSI_ESCAPE.sub("", line)
         length = len(line)
-        lines += 1 * (length // columns + 1 if length > columns else 1)
+        line_lines = 1
+        if length > columns:
+            line_lines = length // columns
+            remainder = length % columns
+            if remainder:
+                line_lines += 1
+        lines += 1 * line_lines
     return lines
 
 
@@ -41,6 +47,9 @@ class ProcessGroup:
     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()
@@ -227,7 +236,7 @@ class ProcessGroup:
 
         for i, command in enumerate(commands):
             try:
-                processes.append(Process.from_command(i + 1, command))
+                processes.append(Process(i + 1, command))
             except InvalidExecutableError as e:
                 errors.append(e)
 
@@ -243,59 +252,69 @@ class ProcessGroup:
 
         return process_group
 
-    def complete_output(self, tail: int = 20, all: bool = False) -> str:
+    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
-
-        if self.process_lines:
-            self.process_lines = []
-
-        for process in self.processes:
-            self.process_lines.append(tail)
-
+        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 = ""
+        output = f"lines = {constants.LINES()}, process_lines = {self.process_lines}\n"
         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
-                output += self._get_command_status(
+                process_output += self._get_command_status(
                     process,
                     passed=process.return_code() == 0,
                     timer=self.timer,
                 )
-                output += "\n"
+                process_output += "\n"
             else:
-                output += self._get_command_status(
+                process_output += self._get_command_status(
                     process,
                     icon=constants.ICONS[self.icon],
                     timer=self.timer,
                 )
-                output += "\n"
+                process_output += "\n"
 
-            process_output = process.read().decode()
+            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] += process_output
-            process_output = self.output[process.id][0]
-            if process_output:
+            self.output[process.id][0] += p_output
+            p_output = self.output[process.id][0]
+            p_output_lines = 0
+            if p_output:
                 if not all:
-                    process_output = "\n".join(
-                        process_output.splitlines()[-self.process_lines[i - 1] :]
-                    )
-                    process_output += "\n"
-                output += self._prefix(process_output)
-                if output and output[-1] != "\n":
-                    output += "\n"
+                    p_output_lines = p_output.splitlines()[-self.process_lines[i - 1] :]
+                    p_output = ""
+                    for line in p_output_lines:
+                        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:
-                    output += "\n"
+                    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