zrb 1.8.1__tar.gz → 1.8.3__tar.gz

{zrb-1.8.1 → zrb-1.8.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zrb
-Version: 1.8.1
+Version: 1.8.3
 Summary: Your Automation Powerhouse
 Home-page: https://github.com/state-alchemists/zrb
 License: AGPL-3.0-or-later
@@ -194,6 +194,36 @@ 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)
 
 
+# 🐋 Running Zrb as a Container
+
+Zrb can be run in a containerized environment, offering two distinct versions to suit different needs:
+
+- **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.
+
+### Standard Version
+
+The standard version of the Zrb container is suitable for most automation tasks. To run this version, execute the following command:
+
+```bash
+# Replace <host-path> and <container-path> with your desired paths
+docker run -v ${HOME}:/zrb-home -it --rm stalchmst/zrb:1.8.1 zrb
+```
+
+### 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
+# 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
 
 - **Full documentation:** [Zrb Documentation](https://github.com/state-alchemists/zrb/blob/main/docs/README.md)
@@ -214,7 +244,7 @@ Then open your browser and visit `http://localhost:21213`
 
 If you find Zrb valuable, please consider donating:
 
-[![](https://raw.githubusercontent.com/state-alchemists/zrb/main/_images/donator.png)](https://stalchmst.com/donation)
+[![](https://raw.githubusercontent.com/state-alchemists/zrb/main/_images/donator.png)](https://stalchmst.com)
 
 # 🎉 Fun Fact
 

{zrb-1.8.1 → zrb-1.8.3}/README.md

@@ -156,6 +156,36 @@ 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)
 
 
+# 🐋 Running Zrb as a Container
+
+Zrb can be run in a containerized environment, offering two distinct versions to suit different needs:
+
+- **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.
+
+### Standard Version
+
+The standard version of the Zrb container is suitable for most automation tasks. To run this version, execute the following command:
+
+```bash
+# Replace <host-path> and <container-path> with your desired paths
+docker run -v ${HOME}:/zrb-home -it --rm stalchmst/zrb:1.8.1 zrb
+```
+
+### 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
+# 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
 
 - **Full documentation:** [Zrb Documentation](https://github.com/state-alchemists/zrb/blob/main/docs/README.md)
@@ -176,7 +206,7 @@ Then open your browser and visit `http://localhost:21213`
 
 If you find Zrb valuable, please consider donating:
 
-[![](https://raw.githubusercontent.com/state-alchemists/zrb/main/_images/donator.png)](https://stalchmst.com/donation)
+[![](https://raw.githubusercontent.com/state-alchemists/zrb/main/_images/donator.png)](https://stalchmst.com)
 
 # 🎉 Fun Fact
 

{zrb-1.8.1 → zrb-1.8.3}/pyproject.toml

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

{zrb-1.8.1 → zrb-1.8.3}/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.1 → zrb-1.8.3}/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.1 → zrb-1.8.3}/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.1 → zrb-1.8.3}/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.1 → zrb-1.8.3}/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.1 → zrb-1.8.3}/src/zrb/config.py

@@ -14,7 +14,7 @@ _DEFAULT_BANNER = """
    zzzzz rr     bbbbbb   {VERSION} Janggala
    _ _ . .  . _ .  _ . . .
 Your Automation Powerhouse
-☕ Donate at: https://stalchmst.com/donation
+☕ Donate at: https://stalchmst.com
 🐙 Submit issues/PR at: https://github.com/state-alchemists/zrb
 🐤 Follow us at: https://twitter.com/zarubastalchmst
 """
@@ -229,10 +229,6 @@ class Config:
     def LLM_PERSONA(self) -> str | None:
         return os.getenv("ZRB_LLM_PERSONA", None)
 
-    @property
-    def LLM_CODE_REVIEW_INSTRUCTION_PROMPT(self) -> str | None:
-        return os.getenv("ZRB_LLM_CODE_REVIEW_INSTRUCTION_PROMPT", None)
-
     @property
     def LLM_SPECIAL_INSTRUCTION_PROMPT(self) -> str | None:
         return os.getenv("ZRB_LLM_SPECIAL_INSTRUCTION_PROMPT", None)

{zrb-1.8.1 → zrb-1.8.3}/src/zrb/llm_config.py

@@ -51,9 +51,9 @@ another JSON object with these details (i.e., {"response": {"context_name": "val
 If no context can be extracted, return {"response": {}}.
 """.strip()
 
-DEFAULT_SPECIAL_INSTRUCTION_PROMPT = ""  # Default to empty
-DEFAULT_CODE_REVIEW_INSTRUCTION_PROMPT = """
-Your goal is to review code provided by the user for correctness, readability,
+DEFAULT_SPECIAL_INSTRUCTION_PROMPT = """
+# Coding and Code Review
+When asked to do coding/code review related task, you prioritize correctness, readability,
 performance, security, and maintainability.
 Follow these principles:
 1. **Correctness** Check whether the code performs the intended logic,
@@ -66,9 +66,10 @@ Follow these principles:
     that could lead to security issues.
 5. **Consistency** Ensure the code adheres to common language idioms,
     style guides, and project conventions.
-Provide clear, concise, and actionable feedback.
-Use inline code examples when helpful.
-Do not restate the code unnecessarily.
+
+## Code Review
+When asked to do code review, you provide clear, concise, and actionable feedback.
+Use inline code examples when helpful. Do not restate the code unnecessarily.
 Focus on meaningful insights that help the user improve the code quality.
 Avoid excessive nitpicking unless requested.
 """.strip()
@@ -84,7 +85,6 @@ class LLMConfig:
         default_persona: str | None = None,
         default_system_prompt: str | None = None,
         default_special_instruction_prompt: str | None = None,
-        default_code_review_instruction_prompt: str | None = None,
         default_summarization_prompt: str | None = None,
         default_context_enrichment_prompt: str | None = None,
         default_summarize_history: bool | None = None,
@@ -101,9 +101,6 @@ class LLMConfig:
         self._default_persona = default_persona
         self._default_system_prompt = default_system_prompt
         self._default_special_instruction_prompt = default_special_instruction_prompt
-        self._default_code_review_instruction_prompt = (
-            default_code_review_instruction_prompt
-        )
         self._default_summarization_prompt = default_summarization_prompt
         self._default_context_enrichment_prompt = default_context_enrichment_prompt
         self._default_summarize_history = default_summarize_history
@@ -175,14 +172,6 @@ class LLMConfig:
             return CFG.LLM_PERSONA
         return DEFAULT_PERSONA
 
-    @property
-    def default_code_review_instruction_prompt(self) -> str:
-        if self._default_code_review_instruction_prompt is not None:
-            return self._default_code_review_instruction_prompt
-        if CFG.LLM_CODE_REVIEW_INSTRUCTION_PROMPT is not None:
-            return CFG.LLM_CODE_REVIEW_INSTRUCTION_PROMPT
-        return DEFAULT_CODE_REVIEW_INSTRUCTION_PROMPT
-
     @property
     def default_special_instruction_prompt(self) -> str:
         if self._default_special_instruction_prompt is not None:

{zrb-1.8.1 → zrb-1.8.3}/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:
@@ -180,16 +186,17 @@ class Session(AnySession):
 
     def defer_monitoring(self, task: AnyTask, coro: Coroutine):
         self._register_single_task(task)
-        self._monitoring_coros[task] = coro
+        self._monitoring_coros[task] = asyncio.create_task(coro)
 
     def defer_action(self, task: AnyTask, coro: Coroutine):
         self._register_single_task(task)
-        self._action_coros[task] = coro
+        self._action_coros[task] = asyncio.create_task(coro)
 
     def defer_coro(self, coro: Coroutine):
-        self._coros.append(coro)
+        task = asyncio.create_task(coro)
+        self._coros.append(task)
         self._coros = [
-            existing_coro for existing_coro in self._coros if not existing_coro.done()
+            existing_task for existing_task in self._coros if not existing_task.done()
         ]
 
     async def wait_deferred(self):

{zrb-1.8.1 → zrb-1.8.3}/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.1 → zrb-1.8.3}/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.1 → zrb-1.8.3}/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.1 → zrb-1.8.3}/src/zrb/task/llm/prompt.py

@@ -52,19 +52,7 @@ def get_special_instruction_prompt(
     )
     if special_instruction is not None:
         return special_instruction
-    aggregated_special_instruction = ""
-    if llm_config.default_code_review_instruction_prompt:
-        aggregated_special_instruction += "\n".join(
-            [
-                "# Code review instruction",
-                llm_config.default_code_review_instruction_prompt,
-            ]
-        )
-    if llm_config.default_special_instruction_prompt:
-        aggregated_special_instruction += "\n" + "\n".join(
-            ["# Code review instruction", llm_config.default_special_instruction_prompt]
-        )
-    return aggregated_special_instruction or ""
+    return llm_config.default_special_instruction_prompt
 
 
 def get_combined_system_prompt(

zrb-1.8.3/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")