zrb 1.8.2__tar.gz → 1.8.4__tar.gz

{zrb-1.8.2 → zrb-1.8.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zrb
-Version: 1.8.2
+Version: 1.8.4
 Summary: Your Automation Powerhouse
 Home-page: https://github.com/state-alchemists/zrb
 License: AGPL-3.0-or-later
@@ -194,31 +194,35 @@ Then open your browser and visit `http://localhost:21213`
 ![Zrb Web UI](https://raw.githubusercontent.com/state-alchemists/zrb/main/_images/zrb-web-ui.png)
 
 
-# 🐋 As Container
+# 🐋 Running Zrb as a Container
 
-Zrb has two version of container:
-- The normal version
-- The dind (Docker in Docker) version
+Zrb can be run in a containerized environment, offering two distinct versions to suit different needs:
 
-The dind version has builtin docker command, and is suitable to access host's docker CLI command.
+- **Standard Version**: Ideal for general use cases where Docker CLI access is not required.
+- **Dind (Docker in Docker) Version**: Includes built-in Docker commands, perfect for scenarios where you need to access the host's Docker CLI.
 
-To run the normal version, you can execute:
+### Standard Version
+
+The standard version of the Zrb container is suitable for most automation tasks. To run this version, execute the following command:
 
 ```bash
-# docker run -v <host-path>:<container-path> -it stalchmst/zrb:<version> <command>
+# Replace <host-path> and <container-path> with your desired paths
 docker run -v ${HOME}:/zrb-home -it --rm stalchmst/zrb:1.8.1 zrb
 ```
 
-While to run the dind version, you can execute:
+### Dind Version
+
+The Dind version is tailored for advanced use cases where Docker commands need to be executed within the container. This version allows the container to interact with the host's Docker daemon. To run the Dind version, use the command below:
 
 ```bash
-# docker run -v <host-path>:<container-path> -it stalchmst/zrb:<version>-dind <command>
+# Replace <host-path> and <container-path> with your desired paths
 docker run \
     -v ${HOME}:/zrb-home \
     -v /var/run/docker.sock:/var/run/docker.sock \
     -it --rm stalchmst/zrb:1.8.1-dind docker ps
 ```
 
+> **Note:** The Dind (Docker in Docker) version of the container is larger in size compared to the standard version due to the inclusion of Docker CLI tools. Consider this when choosing the appropriate version for your needs.
 
 # 🎥 Demo & Documentation
 

{zrb-1.8.2 → zrb-1.8.4}/README.md

@@ -156,31 +156,35 @@ Then open your browser and visit `http://localhost:21213`
 ![Zrb Web UI](https://raw.githubusercontent.com/state-alchemists/zrb/main/_images/zrb-web-ui.png)
 
 
-# 🐋 As Container
+# 🐋 Running Zrb as a Container
 
-Zrb has two version of container:
-- The normal version
-- The dind (Docker in Docker) version
+Zrb can be run in a containerized environment, offering two distinct versions to suit different needs:
 
-The dind version has builtin docker command, and is suitable to access host's docker CLI command.
+- **Standard Version**: Ideal for general use cases where Docker CLI access is not required.
+- **Dind (Docker in Docker) Version**: Includes built-in Docker commands, perfect for scenarios where you need to access the host's Docker CLI.
 
-To run the normal version, you can execute:
+### Standard Version
+
+The standard version of the Zrb container is suitable for most automation tasks. To run this version, execute the following command:
 
 ```bash
-# docker run -v <host-path>:<container-path> -it stalchmst/zrb:<version> <command>
+# Replace <host-path> and <container-path> with your desired paths
 docker run -v ${HOME}:/zrb-home -it --rm stalchmst/zrb:1.8.1 zrb
 ```
 
-While to run the dind version, you can execute:
+### Dind Version
+
+The Dind version is tailored for advanced use cases where Docker commands need to be executed within the container. This version allows the container to interact with the host's Docker daemon. To run the Dind version, use the command below:
 
 ```bash
-# docker run -v <host-path>:<container-path> -it stalchmst/zrb:<version>-dind <command>
+# Replace <host-path> and <container-path> with your desired paths
 docker run \
     -v ${HOME}:/zrb-home \
     -v /var/run/docker.sock:/var/run/docker.sock \
     -it --rm stalchmst/zrb:1.8.1-dind docker ps
 ```
 
+> **Note:** The Dind (Docker in Docker) version of the container is larger in size compared to the standard version due to the inclusion of Docker CLI tools. Consider this when choosing the appropriate version for your needs.
 
 # 🎥 Demo & Documentation
 

{zrb-1.8.2 → zrb-1.8.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "zrb"
-version = "1.8.2"
+version = "1.8.4"
 description = "Your Automation Powerhouse"
 authors = ["Go Frendi Gunawan <gofrendiasgard@gmail.com>"]
 license = "AGPL-3.0-or-later"

{zrb-1.8.2 → zrb-1.8.4}/src/zrb/__main__.py

@@ -60,8 +60,9 @@ def serve_cli():
         # run the CLI
         cli.run(sys.argv[1:])
     except KeyboardInterrupt:
+        # The exception is handled by the task runner
         print(stylize_warning("\nStopped"), file=sys.stderr)
-        sys.exit(1)
+        pass
     except RuntimeError as e:
         if f"{e}".lower() != "event loop is closed":
             raise e

{zrb-1.8.2 → zrb-1.8.4}/src/zrb/builtin/setup/asdf/asdf.py

@@ -22,6 +22,7 @@ install_asdf_prerequisites = CmdTask(
     name="install-asdf-prerequisites",
     input=[package_manager_input, use_sudo_input],
     cmd=get_install_prerequisites_cmd,
+    is_interactive=True,
 )
 
 

{zrb-1.8.2 → zrb-1.8.4}/src/zrb/builtin/setup/tmux/tmux.py

@@ -13,6 +13,7 @@ install_tmux = CmdTask(
     name="install-tmux",
     input=[package_manager_input, use_sudo_input],
     cmd=get_install_tmux_cmd,
+    is_interactive=True,
 )
 
 

{zrb-1.8.2 → zrb-1.8.4}/src/zrb/builtin/setup/ubuntu.py

@@ -1,10 +1,18 @@
 from zrb.builtin.group import setup_group
 from zrb.task.cmd_task import CmdTask
 
-update_ubuntu = CmdTask(name="update-ubuntu", cmd="sudo apt update", render_cmd=False)
+update_ubuntu = CmdTask(
+    name="update-ubuntu",
+    cmd="sudo apt update",
+    render_cmd=False,
+    is_interactive=True,
+)
 
 upgrade_todo = CmdTask(
-    name="upgrade-ubuntu", cmd="sudo apt upgrade -y", render_cmd=False
+    name="upgrade-ubuntu",
+    cmd="sudo apt upgrade -y",
+    render_cmd=False,
+    is_interactive=True,
 )
 update_ubuntu >> upgrade_todo
 
@@ -22,6 +30,7 @@ setup_ubuntu = setup_group.add_task(
             "cmake make tree tmux zsh neovim xdotool xsel",
         ],
         render_cmd=False,
+        is_interactive=True,
     ),
     alias="ubuntu",
 )

{zrb-1.8.2 → zrb-1.8.4}/src/zrb/builtin/setup/zsh/zsh.py

@@ -13,6 +13,7 @@ install_zsh = CmdTask(
     name="install-zsh",
     input=[package_manager_input, use_sudo_input],
     cmd=get_install_zsh_cmd,
+    is_interactive=True,
 )
 
 install_omz = CmdTask(

{zrb-1.8.2 → zrb-1.8.4}/src/zrb/session/session.py

@@ -51,9 +51,9 @@ class Session(AnySession):
         self._shared_ctx = shared_ctx
         self._shared_ctx.set_session(self)
         self._parent = parent
-        self._action_coros: dict[AnyTask, Coroutine] = {}
-        self._monitoring_coros: dict[AnyTask, Coroutine] = {}
-        self._coros: list[Coroutine] = []
+        self._action_coros: dict[AnyTask, asyncio.Task] = {}
+        self._monitoring_coros: dict[AnyTask, asyncio.Task] = {}
+        self._coros: list[asyncio.Task] = []
         self._colors = [
             GREEN,
             YELLOW,
@@ -100,6 +100,12 @@ class Session(AnySession):
         self._is_terminated = True
         for task_status in self._task_status.values():
             task_status.mark_as_terminated()
+        for task in self._action_coros.values():
+            task.cancel()
+        for task in self._monitoring_coros.values():
+            task.cancel()
+        for task in self._coros:
+            task.cancel()
 
     @property
     def is_terminated(self) -> bool:

{zrb-1.8.2 → zrb-1.8.4}/src/zrb/task/base/execution.py

@@ -175,8 +175,7 @@ async def execute_action_with_retry(task: "BaseTask", session: AnySession) -> An
             ctx.log_warning("Task cancelled or interrupted")
             session.get_task_status(task).mark_as_failed()  # Mark as failed on cancel
             # Do not trigger fallbacks/successors on cancellation
-            return  # Or re-raise? Depends on desired cancellation behavior
-
+            raise
         except BaseException as e:
             ctx.log_error(f"Attempt {attempt + 1}/{max_attempt} failed: {e}")
             session.get_task_status(

{zrb-1.8.2 → zrb-1.8.4}/src/zrb/task/base/lifecycle.py

@@ -38,26 +38,30 @@ async def run_and_cleanup(
             ctx = task.get_ctx(session)  # Get context for logging
             ctx.log_info("Terminating session after run completion/error.")
             session.terminate()
-
         # Clean up other potentially running asyncio tasks (excluding the main one)
         # Be cautious with blanket cancellation if other background tasks are expected
-        pending = [
-            t for t in asyncio.all_tasks() if t is not main_task_coro and not t.done()
-        ]
-        if pending:
-            ctx = task.get_ctx(session)  # Get context for logging
-            ctx.log_debug(f"Cleaning up {len(pending)} pending asyncio tasks...")
-            for t in pending:
-                t.cancel()
-            try:
-                # Give cancelled tasks a moment to process cancellation
-                await asyncio.wait(pending, timeout=1.0)
-            except asyncio.CancelledError:
-                # Expected if tasks handle cancellation promptly
-                pass
-            except Exception as cleanup_exc:
-                # Log errors during cleanup if necessary
-                ctx.log_warning(f"Error during task cleanup: {cleanup_exc}")
+        try:
+            pending = [
+                t
+                for t in asyncio.all_tasks()
+                if t is not main_task_coro and not t.done()
+            ]
+            if pending:
+                ctx = task.get_ctx(session)  # Get context for logging
+                ctx.log_debug(f"Cleaning up {len(pending)} pending asyncio tasks...")
+                for t in pending:
+                    t.cancel()
+                try:
+                    # Give cancelled tasks a moment to process cancellation
+                    await asyncio.wait(pending, timeout=1.0)
+                except asyncio.CancelledError:
+                    # Expected if tasks handle cancellation promptly
+                    pass
+                except Exception as cleanup_exc:
+                    # Log errors during cleanup if necessary
+                    ctx.log_warning(f"Error during task cleanup: {cleanup_exc}")
+        except RuntimeError as cleanup_exc:
+            ctx.log_warning(f"Error during task cleanup: {cleanup_exc}")
 
 
 async def run_task_async(

{zrb-1.8.2 → zrb-1.8.4}/src/zrb/task/cmd_task.py

@@ -48,6 +48,7 @@ class CmdTask(BaseTask):
         warn_unrecommended_command: bool | None = None,
         max_output_line: int = 1000,
         max_error_line: int = 1000,
+        is_interactive: bool = False,
         execute_condition: BoolAttr = True,
         retries: int = 2,
         retry_period: float = 0,
@@ -104,6 +105,7 @@ class CmdTask(BaseTask):
         self._max_error_line = max_error_line
         self._should_plain_print = plain_print
         self._should_warn_unrecommended_command = warn_unrecommended_command
+        self._is_interactive = is_interactive
 
     async def _exec_action(self, ctx: AnyContext) -> CmdResult:
         """Turn _cmd attribute into subprocess.Popen and execute it as task's action.
@@ -140,6 +142,7 @@ class CmdTask(BaseTask):
             register_pid_method=lambda pid: ctx.xcom.get(xcom_pid_key).push(pid),
             max_output_line=self._max_output_line,
             max_error_line=self._max_error_line,
+            is_interactive=self._is_interactive,
         )
         # Check for errors
         if return_code > 0:

zrb-1.8.4/src/zrb/util/cmd/command.py

@@ -0,0 +1,192 @@
+import asyncio
+import os
+import re
+import signal
+import sys
+from collections import deque
+from collections.abc import Callable
+from typing import TextIO
+
+import psutil
+
+from zrb.cmd.cmd_result import CmdResult
+
+
+def check_unrecommended_commands(cmd_script: str) -> dict[str, str]:
+    """
+    Check a command script for the use of unrecommended or non-POSIX compliant commands.
+
+    Args:
+        cmd_script (str): The command script string to check.
+
+    Returns:
+        dict[str, str]: A dictionary where keys are the violating commands/patterns
+            and values are the reasons they are unrecommended.
+    """
+    banned_commands = {
+        "<(": "Process substitution isn't POSIX compliant and causes trouble",
+        "column": "Command isn't included in Ubuntu packages and is not POSIX compliant",
+        "echo": "echo isn't consistent across OS; use printf instead",
+        "eval": "Avoid eval as it can accidentally execute arbitrary strings",
+        "realpath": "Not available by default on OSX",
+        "source": "Not POSIX compliant; use '.' instead",
+        " test": "Use '[' instead for consistency",
+        "which": "Command in not POSIX compliant, use command -v",
+    }
+    banned_commands_regex = {
+        r"grep.* -y": "grep -y does not work on Alpine; use grep -i",
+        r"grep.* -P": "grep -P is not valid on OSX",
+        r"grep[^|]+--\w{2,}": "grep long commands do not work on Alpine",
+        r'readlink.+-.*f.+["$]': "readlink -f behaves differently on OSX",
+        r"sort.*-V": "sort -V is not supported everywhere",
+        r"sort.*--sort-versions": "sort --sort-version is not supported everywhere",
+        r"\bls ": "Avoid using ls; use shell globs or find instead",
+    }
+    violations = {}
+    # Check banned commands
+    for cmd, reason in banned_commands.items():
+        if cmd in cmd_script:
+            violations[cmd] = reason
+    # Check banned regex patterns
+    for pattern, reason in banned_commands_regex.items():
+        if re.search(pattern, cmd_script):
+            violations[pattern] = reason
+    return violations
+
+
+async def run_command(
+    cmd: list[str],
+    cwd: str | None = None,
+    env_map: dict[str, str] | None = None,
+    print_method: Callable[..., None] | None = None,
+    register_pid_method: Callable[[int], None] | None = None,
+    max_output_line: int = 1000,
+    max_error_line: int = 1000,
+    is_interactive: bool = False,
+) -> tuple[CmdResult, int]:
+    """
+    Executes a command using the robust `readline` strategy with a memory
+    limit, and correctly handles terminal control characters in the output.
+    Please note that `interactive` execution is generally not recommended and thus
+    disabled by default.
+    When using `interactive execution, the command will not be started in new session
+    and will share the same stdin as the main process, which might trigger race condition.
+    You can use interactive execution for a limited usecase when the command
+    require user input.
+    """
+    actual_print_method = print_method if print_method is not None else print
+    if cwd is None:
+        cwd = os.getcwd()
+    # While environment variables alone weren't the fix, they are still
+    # good practice for encouraging simpler output from tools.
+    child_env = (env_map or os.environ).copy()
+    child_env["TERM"] = "xterm-256color"  # A capable but standard terminal
+    child_env["NO_COLOR"] = "0"  # Explicitly allow color
+    cmd_process = await asyncio.create_subprocess_exec(
+        *cmd,
+        cwd=cwd,
+        env=child_env,
+        start_new_session=not is_interactive,
+        stdin=__get_cmd_stdin(is_interactive),
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+        limit=10 * 10 * 1024,  # Buffer memory limit
+    )
+    if register_pid_method is not None:
+        register_pid_method(cmd_process.pid)
+    # Use the new, simple, and correct stream reader.
+    stdout_task = asyncio.create_task(
+        __read_stream(cmd_process.stdout, actual_print_method, max_output_line)
+    )
+    stderr_task = asyncio.create_task(
+        __read_stream(cmd_process.stderr, actual_print_method, max_error_line)
+    )
+    try:
+        return_code = await cmd_process.wait()
+        stdout, stderr = await asyncio.gather(stdout_task, stderr_task)
+        return CmdResult(stdout, stderr), return_code
+    except (KeyboardInterrupt, asyncio.CancelledError):
+        try:
+            os.killpg(cmd_process.pid, signal.SIGINT)
+            await asyncio.wait_for(cmd_process.wait(), timeout=2.0)
+        except asyncio.TimeoutError:
+            # If it doesn't terminate, kill it forcefully
+            actual_print_method(
+                f"Process {cmd_process.pid} did not terminate gracefully, killing."
+            )
+            kill_pid(cmd_process.pid, print_method=actual_print_method)
+        except Exception:
+            pass
+        # Final cleanup
+        stdout_task.cancel()
+        stderr_task.cancel()
+        await asyncio.gather(stdout_task, stderr_task, return_exceptions=True)
+        raise
+
+
+def __get_cmd_stdin(is_interactive: bool) -> int | TextIO:
+    if is_interactive and sys.stdin.isatty():
+        return sys.stdin
+    return asyncio.subprocess.DEVNULL
+
+
+async def __read_stream(
+    stream: asyncio.StreamReader,
+    print_method: Callable[..., None],
+    max_lines: int,
+) -> str:
+    """
+    Reads from the stream using the robust `readline()` and correctly
+    interprets carriage returns (`\r`) as distinct print events.
+    """
+    captured_lines = deque(maxlen=max_lines if max_lines > 0 else 0)
+    while True:
+        try:
+            line_bytes = await stream.readline()
+            if not line_bytes:
+                break
+        except ValueError:
+            # Safety valve for the memory limit.
+            error_msg = "[ERROR] A single line of output was too long to process."
+            print_method(error_msg)
+            if max_lines > 0:
+                captured_lines.append(error_msg)
+            break
+        except (KeyboardInterrupt, asyncio.CancelledError):
+            raise
+        except Exception:
+            break
+        decoded_line = line_bytes.decode("utf-8", errors="replace")
+        parts = decoded_line.replace("\r", "\n").splitlines()
+        for part in parts:
+            clean_part = part.rstrip()
+            if clean_part:
+                try:
+                    print_method(clean_part, end="\r\n")
+                except Exception:
+                    print_method(clean_part)
+                if max_lines > 0:
+                    captured_lines.append(clean_part)
+    return "\r\n".join(captured_lines)
+
+
+def kill_pid(pid: int, print_method: Callable[..., None] | None = None):
+    """
+    Kill a process and its children given the parent process ID.
+
+    Args:
+        pid (int): The process ID of the parent process.
+        print_method (Callable[..., None] | None): A method to print status messages.
+            Defaults to the built-in print function.
+    """
+    actual_print_method = print_method if print_method is not None else print
+    try:
+        parent = psutil.Process(pid)
+        children = parent.children(recursive=True)
+        for child in children:
+            actual_print_method(f"Killing child process {child.pid}")
+            child.kill()
+        actual_print_method(f"Killing process {pid}")
+        parent.kill()
+    except psutil.NoSuchProcess:
+        actual_print_method(f"Process with pid: {pid} already terminated")

{zrb-1.8.2 → zrb-1.8.4}/src/zrb/util/run.py

@@ -13,6 +13,8 @@ async def run_async(value: Any) -> Any:
     Returns:
         Any: The result of the awaited value or the value itself if not awaitable.
     """
+    if isinstance(value, asyncio.Task):
+        return value
     if inspect.isawaitable(value):
         return await value
     return await asyncio.to_thread(lambda: value)

zrb-1.8.2/src/zrb/util/cmd/command.py

@@ -1,141 +0,0 @@
-import asyncio
-import os
-import re
-import sys
-from collections.abc import Callable
-
-import psutil
-
-from zrb.cmd.cmd_result import CmdResult
-
-
-def check_unrecommended_commands(cmd_script: str) -> dict[str, str]:
-    """
-    Check a command script for the use of unrecommended or non-POSIX compliant commands.
-
-    Args:
-        cmd_script (str): The command script string to check.
-
-    Returns:
-        dict[str, str]: A dictionary where keys are the violating commands/patterns
-            and values are the reasons they are unrecommended.
-    """
-    banned_commands = {
-        "<(": "Process substitution isn't POSIX compliant and causes trouble",
-        "column": "Command isn't included in Ubuntu packages and is not POSIX compliant",
-        "echo": "echo isn't consistent across OS; use printf instead",
-        "eval": "Avoid eval as it can accidentally execute arbitrary strings",
-        "realpath": "Not available by default on OSX",
-        "source": "Not POSIX compliant; use '.' instead",
-        " test": "Use '[' instead for consistency",
-        "which": "Command in not POSIX compliant, use command -v",
-    }
-    banned_commands_regex = {
-        r"grep.* -y": "grep -y does not work on Alpine; use grep -i",
-        r"grep.* -P": "grep -P is not valid on OSX",
-        r"grep[^|]+--\w{2,}": "grep long commands do not work on Alpine",
-        r'readlink.+-.*f.+["$]': "readlink -f behaves differently on OSX",
-        r"sort.*-V": "sort -V is not supported everywhere",
-        r"sort.*--sort-versions": "sort --sort-version is not supported everywhere",
-        r"\bls ": "Avoid using ls; use shell globs or find instead",
-    }
-    violations = {}
-    # Check banned commands
-    for cmd, reason in banned_commands.items():
-        if cmd in cmd_script:
-            violations[cmd] = reason
-    # Check banned regex patterns
-    for pattern, reason in banned_commands_regex.items():
-        if re.search(pattern, cmd_script):
-            violations[pattern] = reason
-    return violations
-
-
-async def run_command(
-    cmd: list[str],
-    cwd: str | None = None,
-    env_map: dict[str, str] | None = None,
-    print_method: Callable[..., None] | None = None,
-    register_pid_method: Callable[[int], None] | None = None,
-    max_output_line: int = 1000,
-    max_error_line: int = 1000,
-) -> tuple[CmdResult, int]:
-    async def __read_stream(
-        stream, print_method: Callable[..., None], max_lines: int
-    ) -> str:
-        lines = []
-        if hasattr(stream, "_limit"):
-            # The limit is set to 10 MB
-            stream._limit = 1024 * 1024 * 10
-        while True:
-            line = None
-            try:
-                line = await stream.readline()
-            except asyncio.exceptions.CancelledError:
-                pass
-            except asyncio.exceptions.LimitOverrunError as e:
-                # Recover by reading a limited chunk instead
-                await stream.read(e.consumed)
-                line = "<output line too long>"
-            except BaseException as e:
-                line = f"Error while reading stream {type(e)} {e}"
-                pass
-            if not line:
-                break
-            try:
-                line = line.decode("utf-8").rstrip()
-            except Exception:
-                pass
-            lines.append(line)
-            if len(lines) > max_lines:
-                lines.pop(0)  # Keep only the last max_lines
-            print_method(line)
-        return "\n".join(lines)
-
-    actual_print_method = print_method if print_method is not None else print
-    cmd_process = None
-    if cwd is None:
-        cwd = os.getcwd()
-    if env_map is None:
-        env_map = os.environ
-    cmd_process = await asyncio.create_subprocess_exec(
-        *cmd,
-        cwd=cwd,
-        stdin=sys.stdin if sys.stdin.isatty() else None,
-        stdout=asyncio.subprocess.PIPE,
-        stderr=asyncio.subprocess.PIPE,
-        env=env_map,
-        bufsize=0,
-    )
-    if register_pid_method is not None:
-        register_pid_method(cmd_process.pid)
-    stdout_task = asyncio.create_task(
-        __read_stream(cmd_process.stdout, actual_print_method, max_output_line)
-    )
-    stderr_task = asyncio.create_task(
-        __read_stream(cmd_process.stderr, actual_print_method, max_error_line)
-    )
-    # Wait for process to complete and gather stdout/stderr
-    return_code = await cmd_process.wait()
-    stdout = await stdout_task
-    stderr = await stderr_task
-    return CmdResult(stdout, stderr), return_code
-
-
-def kill_pid(pid: int, print_method: Callable[..., None] | None = None):
-    """
-    Kill a process and its children given the parent process ID.
-
-    Args:
-        pid (int): The process ID of the parent process.
-        print_method (Callable[..., None] | None): A method to print status messages.
-            Defaults to the built-in print function.
-    """
-    actual_print_method = print_method if print_method is not None else print
-    parent = psutil.Process(pid)
-    children = parent.children(recursive=True)
-    for child in children:
-        actual_print_method(f"Killing child process {child.pid}")
-        child.terminate()
-    actual_print_method(f"Killing process {pid}")
-    parent.terminate()