zrb 0.26.1__py3-none-any.whl → 0.27.0__py3-none-any.whl

zrb/__init__.py

@@ -10,7 +10,6 @@ from zrb.task.any_task_event_handler import (
     OnTriggered,
     OnWaiting,
 )
-from zrb.task.base_remote_cmd_task import BaseRemoteCmdTask, RemoteConfig
 from zrb.task.checker import Checker
 from zrb.task.cmd_task import CmdTask
 from zrb.task.decorator import python_task
@@ -69,8 +68,6 @@ assert CmdTask
 assert DockerComposeTask
 assert DockerComposeStartTask
 assert ServiceConfig
-assert BaseRemoteCmdTask
-assert RemoteConfig
 assert RemoteCmdTask
 assert RsyncTask
 assert Notifier

zrb/builtin/monorepo/_common.sh

@@ -0,0 +1,15 @@
+log_info() {
+    echo -e "🤖 \e[0;33m${1}\e[0;0m"
+}
+
+log_error() {
+    echo -e "\e[1;31m${1}\e[0;0m" >&2
+}
+
+log_conflict_error() {
+    log_error "Action blocked by unresolved conflicts."
+    log_error "You need to resolve the conflict(s) and commit the changes."
+    log_error "Unresolved conflict(s) detected:"
+    log_error "$1"
+}
+

zrb/builtin/monorepo/_helper.py

@@ -0,0 +1,140 @@
+import os
+
+from zrb.builtin.monorepo._config import PROJECT_DIR
+from zrb.task.cmd_task import CmdTask
+from zrb.task_env.env import Env
+from zrb.task_input.any_input import AnyInput
+from zrb.task_input.str_input import StrInput
+
+_CURRENT_DIR = os.path.dirname(__file__)
+
+
+def create_pull_monorepo_task(
+    task_name: str = "pull-monorepo",
+) -> CmdTask:
+    return CmdTask(
+        name=task_name,
+        envs=[
+            Env("TIME", os_name="", default="{{datetime.datetime.now()}}"),
+        ],
+        cmd_path=[
+            os.path.join(_CURRENT_DIR, "_common.sh"),
+            os.path.join(_CURRENT_DIR, "pull-monorepo.sh"),
+        ],
+        cwd=PROJECT_DIR,
+        should_show_cmd=False,
+        should_show_working_directory=False,
+        should_print_cmd_result=False,
+        retry=0,
+    )
+
+
+def create_push_monorepo_task(
+    task_name: str = "push-monorepo", default_commit_message: str = "Save changes"
+) -> CmdTask:
+    return CmdTask(
+        name=task_name,
+        inputs=[_create_commit_message_input(default_commit_message)],
+        envs=[
+            Env("MESSAGE", os_name="", default="{{input.message}}"),
+        ],
+        cmd_path=[
+            os.path.join(_CURRENT_DIR, "_common.sh"),
+            os.path.join(_CURRENT_DIR, "push-monorepo.sh"),
+        ],
+        cwd=PROJECT_DIR,
+        should_show_cmd=False,
+        should_show_working_directory=False,
+        should_print_cmd_result=False,
+        retry=0,
+    )
+
+
+def create_add_subrepo_task(
+    origin: str,
+    folder: str,
+    branch: str,
+    task_name: str = "add",
+) -> CmdTask:
+    return CmdTask(
+        name=task_name,
+        envs=[
+            Env("ORIGIN", os_name="", default=origin),
+            Env("FOLDER", os_name="", default=folder),
+            Env("BRANCH", os_name="", default=branch),
+            Env("TIME", os_name="", default="{{datetime.datetime.now()}}"),
+        ],
+        cmd_path=[
+            os.path.join(_CURRENT_DIR, "_common.sh"),
+            os.path.join(_CURRENT_DIR, "add-subrepo.sh"),
+        ],
+        cwd=PROJECT_DIR,
+        should_show_cmd=False,
+        should_show_working_directory=False,
+        should_print_cmd_result=False,
+        retry=0,
+    )
+
+
+def create_pull_subrepo_task(
+    origin: str,
+    folder: str,
+    branch: str,
+    task_name: str = "pull",
+) -> CmdTask:
+    return CmdTask(
+        name=task_name,
+        envs=[
+            Env("ORIGIN", os_name="", default=origin),
+            Env("FOLDER", os_name="", default=folder),
+            Env("BRANCH", os_name="", default=branch),
+            Env("TIME", os_name="", default="{{datetime.datetime.now()}}"),
+        ],
+        cmd_path=[
+            os.path.join(_CURRENT_DIR, "_common.sh"),
+            os.path.join(_CURRENT_DIR, "pull-subrepo.sh"),
+        ],
+        cwd=PROJECT_DIR,
+        should_show_cmd=False,
+        should_show_working_directory=False,
+        should_print_cmd_result=False,
+        retry=0,
+    )
+
+
+def create_push_subrepo_task(
+    origin: str,
+    folder: str,
+    branch: str,
+    task_name: str = "push",
+    default_commit_message: str = "Commit",
+) -> CmdTask:
+    return CmdTask(
+        name=task_name,
+        inputs=[_create_commit_message_input(default_commit_message)],
+        envs=[
+            Env("ORIGIN", os_name="", default=origin),
+            Env("FOLDER", os_name="", default=folder),
+            Env("BRANCH", os_name="", default=branch),
+            Env("TIME", os_name="", default="{{datetime.datetime.now()}}"),
+            Env("MESSAGE", os_name="", default="{{input.message}}"),
+        ],
+        cmd_path=[
+            os.path.join(_CURRENT_DIR, "_common.sh"),
+            os.path.join(_CURRENT_DIR, "push-subrepo.sh"),
+        ],
+        cwd=PROJECT_DIR,
+        should_show_cmd=False,
+        should_show_working_directory=False,
+        should_print_cmd_result=False,
+        retry=0,
+    )
+
+
+def _create_commit_message_input(default: str) -> AnyInput:
+    return StrInput(
+        name="message",
+        shortcut="m",
+        prompt="Commit Message",
+        default=default,
+    )

zrb/builtin/monorepo/_task.py

@@ -1,25 +1,18 @@
-import os
-from datetime import datetime
-
-from zrb.builtin.monorepo._config import MONOREPO_CONFIG, PROJECT_DIR
+from zrb.builtin.monorepo._config import MONOREPO_CONFIG
 from zrb.builtin.monorepo._group import monorepo_group
+from zrb.builtin.monorepo._helper import (
+    create_add_subrepo_task,
+    create_pull_monorepo_task,
+    create_pull_subrepo_task,
+    create_push_monorepo_task,
+    create_push_subrepo_task,
+)
 from zrb.helper.util import to_kebab_case
 from zrb.runner import runner
-from zrb.task.cmd_task import CmdTask
+from zrb.task.flow_task import FlowTask
 from zrb.task_group.group import Group
-from zrb.task_input.str_input import StrInput
 
-_pull_monorepo = CmdTask(
-    name="pull-monorepo",
-    inputs=[StrInput(name="message")],
-    cmd=[
-        "git add . -A",
-        'git commit -m "{{input.message}}"',
-        'git pull origin "$(git branch --show-current)"',
-    ],
-    cwd=PROJECT_DIR,
-    retry=0,
-)
+_pull_monorepo = create_pull_monorepo_task()
 
 PULL_SUBREPO_UPSTREAM = _pull_monorepo
 PUSH_SUBREPO_UPSTREAM = _pull_monorepo
@@ -28,72 +21,106 @@ for name, config in MONOREPO_CONFIG.items():
     group = Group(
         name=kebab_name, parent=monorepo_group, description=f"Subrepo {name} management"
     )
-    subrepo_origin = config.get("origin", "")
-    subrepo_folder = config.get("folder", "")
-    subrepo_branch = config.get("branch", "main")
+    origin = config.get("origin", "")
+    folder = config.get("folder", "")
+    branch = config.get("branch", "main")
 
-    # define pull subrepo
-    pull_subrepo = CmdTask(
+    pull_subrepo = FlowTask(
         name="pull",
         group=group,
-        inputs=[
-            StrInput(
-                name="message",
-                shortcut="m",
-                prompt="Commit Messsage",
-                default=lambda m: f"Pulling from subrepo at {datetime.now().strftime('%Y-%m-%d %I:%M:%p')}",  # noqa
-            )
+        upstreams=[_pull_monorepo],
+        steps=[
+            create_add_subrepo_task(
+                origin=origin,
+                folder=folder,
+                branch=branch,
+                task_name=f"add-{kebab_name}-subrepo",
+            ),
+            create_pull_subrepo_task(
+                origin=origin,
+                folder=folder,
+                branch=branch,
+                task_name=f"pull-{kebab_name}-subrepo",
+            ),
         ],
-        cmd=[
-            f'if [ ! -d "{subrepo_folder}" ]',
-            "then",
-            "  echo Run subtree add",
-            f'  git subtree add --prefix "{subrepo_folder}" "{subrepo_origin}" "{subrepo_branch}"',  # noqa
-            "fi",
-            "echo Run subtree pull",
-            "set -e",
-            f'git subtree pull --prefix "{subrepo_folder}" "{subrepo_origin}" "{subrepo_branch}"',  # noqa
+    )
+    runner.register(pull_subrepo)
+
+    linked_pull_subrepo = FlowTask(
+        name=f"pull-{kebab_name}",
+        upstreams=[PULL_SUBREPO_UPSTREAM],
+        steps=[
+            create_add_subrepo_task(
+                origin=origin,
+                folder=folder,
+                branch=branch,
+                task_name=f"add-{kebab_name}-subrepo",
+            ),
+            create_pull_subrepo_task(
+                origin=origin,
+                folder=folder,
+                branch=branch,
+                task_name=f"pull-{kebab_name}-subrepo",
+            ),
         ],
-        cwd=PROJECT_DIR,
-        retry=0,
     )
-    _pull_monorepo >> pull_subrepo
-    linked_pull_subrepo = pull_subrepo.copy()
-    PULL_SUBREPO_UPSTREAM >> linked_pull_subrepo
     PULL_SUBREPO_UPSTREAM = linked_pull_subrepo
-    runner.register(pull_subrepo)
 
-    # define push subrepo
-    push_subrepo = CmdTask(
+    push_subrepo = FlowTask(
         name="push",
         group=group,
-        inputs=[
-            StrInput(
-                name="message",
-                shortcut="m",
-                prompt="Commit Messsage",
-                default=lambda m: f"Pushing to subrepo at {datetime.now().strftime('%Y-%m-%d %I:%M:%p')}",  # noqa
-            )
+        upstreams=[_pull_monorepo],
+        steps=[
+            create_add_subrepo_task(
+                origin=origin,
+                folder=folder,
+                branch=branch,
+                task_name=f"add-{kebab_name}-subrepo",
+            ),
+            create_pull_subrepo_task(
+                origin=origin,
+                folder=folder,
+                branch=branch,
+                task_name=f"pull-{kebab_name}-subrepo",
+            ),
+            create_push_subrepo_task(
+                origin=origin,
+                folder=folder,
+                branch=branch,
+                task_name=f"push-{kebab_name}-subrepo",
+            ),
+            create_push_monorepo_task(task_name="push-monorepo"),
         ],
-        cmd=[
-            f'if [ ! -d "{subrepo_folder}" ]',
-            "then",
-            "  echo Run subtree add",
-            f'  git subtree add --prefix "{subrepo_folder}" "{subrepo_origin}" "{subrepo_branch}"',  # noqa
-            "fi",
-            "echo Run subtree pull",
-            "set -e",
-            f'git subtree pull --prefix "{subrepo_folder}" "{subrepo_origin}" "{subrepo_branch}"',  # noqa
-            "set +e",
-            "git add . -A",
-            'git commit -m "{{input.message}}"',
-            f'git subtree push --prefix "{subrepo_folder}" "{subrepo_origin}" "{subrepo_branch}"',  # noqa
+    )
+    runner.register(push_subrepo)
+
+    linked_push_subrepo = FlowTask(
+        name=f"push-{kebab_name}",
+        upstreams=[PUSH_SUBREPO_UPSTREAM],
+        steps=[
+            create_add_subrepo_task(
+                origin=origin,
+                folder=folder,
+                branch=branch,
+                task_name=f"add-{kebab_name}-subrepo",
+            ),
+            create_pull_subrepo_task(
+                origin=origin,
+                folder=folder,
+                branch=branch,
+                task_name=f"pull-{kebab_name}-subrepo",
+            ),
+            create_push_subrepo_task(
+                origin=origin,
+                folder=folder,
+                branch=branch,
+                task_name=f"push-{kebab_name}-subrepo",
+            ),
         ],
-        cwd=PROJECT_DIR,
-        retry=0,
     )
-    _pull_monorepo >> push_subrepo
-    linked_push_subrepo = push_subrepo.copy()
-    PUSH_SUBREPO_UPSTREAM >> linked_push_subrepo
     PUSH_SUBREPO_UPSTREAM = linked_push_subrepo
-    runner.register(push_subrepo)
+
+
+_push_monorepo = create_push_monorepo_task(task_name="push-monorepo")
+PUSH_SUBREPO_UPSTREAM >> _push_monorepo
+PUSH_SUBREPO_UPSTREAM = _push_monorepo

zrb/builtin/monorepo/add-subrepo.sh

@@ -0,0 +1,22 @@
+set -e
+
+if [ -d "${FOLDER}" ]
+then
+    exit 0
+fi
+
+CONFLICT="$(git diff --name-only --diff-filter=U)"
+if [ -n "${CONFLICT}" ]
+then
+    log_conflict_error "${CONFLICT}"
+    exit 1
+fi
+
+log_info "Adding subtree: ${FOLDER}"
+git subtree add --prefix "${FOLDER}" "${ORIGIN}" "${BRANCH}"
+git add . -A
+if [ -n "$(git status --porcelain)" ]
+then
+    log_info "Commit changes"
+    git commit -m "Adding subtree: ${FOLDER} at ${TIME}"
+fi

zrb/builtin/monorepo/pull-monorepo.sh

@@ -0,0 +1,18 @@
+set -e
+
+CONFLICT="$(git diff --name-only --diff-filter=U)"
+if [ -n "${CONFLICT}" ]
+then
+    log_conflict_error "${CONFLICT}"
+    exit 1
+fi
+
+git add . -A
+if [ -n "$(git status --porcelain)" ]
+then
+    log_info "Commit changes"
+    git commit -m "Before pulling from monorepo at ${TIME}"
+fi
+
+log_info "Pulling from main repository"
+git pull origin "$(git branch --show-current)"

zrb/builtin/monorepo/pull-subrepo.sh

@@ -0,0 +1,18 @@
+set -e
+
+CONFLICT="$(git diff --name-only --diff-filter=U)"
+if [ -n "${CONFLICT}" ]
+then
+    log_conflict_error "${CONFLICT}"
+    exit 1
+fi
+
+log_info "Pulling from subtree"
+git subtree pull --prefix "${FOLDER}" "${ORIGIN}" "${BRANCH}"
+
+CONFLICT="$(git diff --name-only --diff-filter=U)"
+if [ -n "${CONFLICT}" ]
+then
+    log_conflict_error "${CONFLICT}"
+    exit 1
+fi

zrb/builtin/monorepo/pull.py

@@ -15,9 +15,10 @@ pull_from_monorepo = Task(
             name="message",
             shortcut="m",
             prompt="Commit Messsage",
-            default=lambda m: f"Pulling from subrepos at {datetime.now().strftime('%Y-%m-%d %I:%M:%p')}",  # noqa
+            default=lambda m: f"Synchronize subrepos at {datetime.now()}",
         )
     ],
+    retry=0,
 )
 PULL_SUBREPO_UPSTREAM >> pull_from_monorepo
 runner.register(pull_from_monorepo)

zrb/builtin/monorepo/push-monorepo.sh

@@ -0,0 +1,18 @@
+set -e
+
+CONFLICT="$(git diff --name-only --diff-filter=U)"
+if [ -n "${CONFLICT}" ]
+then
+    log_conflict_error "${CONFLICT}"
+    exit 1
+fi
+
+git add . -A
+if [ -n "$(git status --porcelain)" ]
+then
+    log_info "Commit changes"
+    git commit -m "${MESSAGE}"
+fi
+
+log_info "Pushing to main repository"
+git push origin "$(git branch --show-current)"

zrb/builtin/monorepo/push-subrepo.sh

@@ -0,0 +1,18 @@
+set -e
+
+CONFLICT="$(git diff --name-only --diff-filter=U)"
+if [ -n "${CONFLICT}" ]
+then
+    log_conflict_error "${CONFLICT}"
+    exit 1
+fi
+
+git add . -A
+if [ -n "$(git status --porcelain)" ]
+then
+    log_info "Commit changes"
+    git commit -m "${MESSAGE}"
+fi
+
+log_info "Pushing to subtree"
+git subtree push --prefix "${FOLDER}" "${ORIGIN}" "${BRANCH}"

zrb/builtin/monorepo/push.py

@@ -1,26 +1,11 @@
-import os
 from datetime import datetime
 
-from zrb.builtin.monorepo._config import PROJECT_DIR
 from zrb.builtin.monorepo._group import monorepo_group
 from zrb.builtin.monorepo._task import PUSH_SUBREPO_UPSTREAM
 from zrb.runner import runner
-from zrb.task.cmd_task import CmdTask
 from zrb.task.task import Task
 from zrb.task_input.str_input import StrInput
 
-_push_monorepo = CmdTask(
-    name="push-monorepo",
-    inputs=[StrInput(name="message")],
-    cmd=[
-        "git add . -A",
-        'git commit -m "{{input.message}}"',
-        'git push origin "$(git branch --show-current)"',
-    ],
-    cwd=PROJECT_DIR,
-    retry=0,
-)
-
 push_to_monorepo = Task(
     name="push",
     group=monorepo_group,
@@ -30,9 +15,10 @@ push_to_monorepo = Task(
             name="message",
             shortcut="m",
             prompt="Commit Messsage",
-            default=lambda m: f"Pushing to subrepos at {datetime.now().strftime('%Y-%m-%d %I:%M:%p')}",  # noqa
+            default=lambda m: f"Synchronize subrepos at {datetime.now()}",
         )
     ],
+    retry=0,
 )
-PUSH_SUBREPO_UPSTREAM >> _push_monorepo >> push_to_monorepo
+PUSH_SUBREPO_UPSTREAM >> push_to_monorepo
 runner.register(push_to_monorepo)

zrb/task/base_task/base_task.py

@@ -288,7 +288,7 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
             self._print_result(result)
             return result
         except RuntimeError as e:
-            if "event loop is closed" not in str(e).lower():
+            if raise_error and ("event loop is closed" not in str(e).lower()):
                 raise e
         except Exception as e:
             self.log_error(f"{e}")

zrb/task/docker_compose_task.py

@@ -33,32 +33,33 @@ from zrb.task_input.any_input import AnyInput
 
 logger.debug(colored("Loading zrb.task.docker_compose_task", attrs=["dark"]))
 
+TDockerComposeTask = TypeVar("TDockerComposeTask", bound="DockerComposeTask")
 
-def _get_ensure_zrb_network_task(backend: str):
-    CURRENT_DIR = os.path.dirname(__file__)
-    SHELL_SCRIPT_DIR = os.path.join(CURRENT_DIR, "..", "shell-scripts")
-    ensure_container_backend = CmdTask(
-        name="ensure-compose-backend",
-        cmd_path=[
-            os.path.join(SHELL_SCRIPT_DIR, "_common-util.sh"),
-            os.path.join(SHELL_SCRIPT_DIR, f"ensure-{backend}-is-installed.sh"),
-        ],
-        preexec_fn=None,
-        should_print_cmd_result=False,
-    )
-    return CmdTask(
-        name="ensure-zrb-network",
-        cmd=[
-            f"{backend} network inspect zrb >/dev/null 2>&1 || \\",
-            f"{backend} network create -d bridge zrb",
-        ],
-        upstreams=[ensure_container_backend],
-        should_print_cmd_result=False,
-    )
-
+CURRENT_DIR = os.path.dirname(__file__)
+SHELL_SCRIPT_DIR = os.path.join(CURRENT_DIR, "..", "shell-scripts")
 
-TDockerComposeTask = TypeVar("TDockerComposeTask", bound="DockerComposeTask")
-ensure_zrb_network_task = _get_ensure_zrb_network_task(CONTAINER_BACKEND)
+ensure_container_backend = CmdTask(
+    name="ensure-compose-backend",
+    cmd_path=[
+        os.path.join(SHELL_SCRIPT_DIR, "_common-util.sh"),
+        os.path.join(SHELL_SCRIPT_DIR, f"ensure-{CONTAINER_BACKEND}-is-installed.sh"),
+    ],
+    preexec_fn=None,
+    should_print_cmd_result=False,
+    should_show_cmd=False,
+    should_show_working_directory=False,
+)
+ensure_zrb_network_task = CmdTask(
+    name="ensure-zrb-network",
+    cmd=[
+        f"{CONTAINER_BACKEND} network inspect zrb >/dev/null 2>&1 || \\",
+        f"{CONTAINER_BACKEND} network create -d bridge zrb",
+    ],
+    upstreams=[ensure_container_backend],
+    should_print_cmd_result=False,
+    should_show_cmd=False,
+    should_show_working_directory=False,
+)
 
 
 @typechecked
@@ -120,14 +121,13 @@ class DockerComposeTask(CmdTask):
         should_show_cmd: bool = True,
         should_show_working_directory: bool = True,
     ):
-        combined_env_files = list(env_files)
         CmdTask.__init__(
             self,
             name=name,
             group=group,
             inputs=inputs,
             envs=envs,
-            env_files=combined_env_files,
+            env_files=env_files,
             icon=icon,
             color=color,
             description=description,

zrb/task/flow_task.py

@@ -85,7 +85,6 @@ class FlowTask(BaseTask):
             retry_interval=retry_interval,
             should_execute=should_execute,
             return_upstream_result=return_upstream_result,
-            run=lambda *args, **kwargs: kwargs.get("_task").print_out("🆗"),
         )
 
     def copy(self) -> TFlowTask:

zrb/task/remote_cmd_task.py

@@ -6,6 +6,7 @@ from typing import Any, Optional, Union
 from zrb.helper.accessories.color import colored
 from zrb.helper.log import logger
 from zrb.helper.typecheck import typechecked
+from zrb.helper.typing import JinjaTemplate
 from zrb.task.any_task import AnyTask
 from zrb.task.any_task_event_handler import (
     OnFailed,
@@ -16,7 +17,6 @@ from zrb.task.any_task_event_handler import (
     OnTriggered,
     OnWaiting,
 )
-from zrb.task.base_remote_cmd_task import BaseRemoteCmdTask, RemoteConfig
 from zrb.task.cmd_task import CmdTask, CmdVal
 from zrb.task_env.env import Env
 from zrb.task_env.env_file import EnvFile
@@ -37,15 +37,17 @@ ensure_ssh_is_installed = CmdTask(
         os.path.join(_SHELL_SCRIPT_DIR, "ensure-ssh-is-installed.sh"),
     ],
     preexec_fn=None,
+    should_print_cmd_result=False,
+    should_show_cmd=False,
+    should_show_working_directory=False,
 )
 
 
 @typechecked
-class RemoteCmdTask(BaseRemoteCmdTask):
+class RemoteCmdTask(CmdTask):
     def __init__(
         self,
         name: str,
-        remote_configs: Iterable[RemoteConfig],
         group: Optional[Group] = None,
         inputs: Iterable[AnyInput] = [],
         envs: Iterable[Env] = [],
@@ -54,9 +56,15 @@ class RemoteCmdTask(BaseRemoteCmdTask):
         color: Optional[str] = None,
         description: str = "",
         executable: Optional[str] = None,
+        remote_host: JinjaTemplate = "localhost",
+        remote_port: Union[JinjaTemplate, int] = 22,
+        remote_user: JinjaTemplate = "root",
+        remote_password: JinjaTemplate = "",
+        remote_ssh_key: JinjaTemplate = "",
         cmd: CmdVal = "",
         cmd_path: CmdVal = "",
         cwd: Optional[Union[str, pathlib.Path]] = None,
+        should_render_cwd: bool = True,
         upstreams: Iterable[AnyTask] = [],
         fallbacks: Iterable[AnyTask] = [],
         on_triggered: Optional[OnTriggered] = None,
@@ -74,18 +82,14 @@ class RemoteCmdTask(BaseRemoteCmdTask):
         max_error_line: int = 1000,
         preexec_fn: Optional[Callable[[], Any]] = os.setsid,
         should_execute: Union[bool, str, Callable[..., bool]] = True,
+        return_upstream_result: bool = False,
+        should_print_cmd_result: bool = True,
+        should_show_cmd: bool = True,
+        should_show_working_directory: bool = True,
     ):
-        pre_cmd = "\n".join(
-            [
-                _SSH_UTIL_SCRIPT,
-                "_SCRIPT=\"$(cat <<'ENDSCRIPT'",
-            ]
-        )
-        post_cmd = "\n".join(["ENDSCRIPT", ')"', 'auth_ssh "$_SCRIPT"'])
-        BaseRemoteCmdTask.__init__(
+        CmdTask.__init__(
             self,
             name=name,
-            remote_configs=remote_configs,
             group=group,
             inputs=inputs,
             envs=envs,
@@ -94,11 +98,10 @@ class RemoteCmdTask(BaseRemoteCmdTask):
             color=color,
             description=description,
             executable=executable,
-            pre_cmd=pre_cmd,
             cmd=cmd,
             cmd_path=cmd_path,
-            post_cmd=post_cmd,
             cwd=cwd,
+            should_render_cwd=should_render_cwd,
             upstreams=[ensure_ssh_is_installed] + upstreams,
             fallbacks=fallbacks,
             on_triggered=on_triggered,
@@ -116,4 +119,40 @@ class RemoteCmdTask(BaseRemoteCmdTask):
             max_error_line=max_error_line,
             preexec_fn=preexec_fn,
             should_execute=should_execute,
+            return_upstream_result=return_upstream_result,
+            should_print_cmd_result=should_print_cmd_result,
+            should_show_cmd=should_show_cmd,
+            should_show_working_directory=should_show_working_directory,
+        )
+        self._remote_host = remote_host
+        self._remote_port = remote_port
+        self._remote_user = remote_user
+        self._remote_password = remote_password
+        self._remote_ssh_key = remote_ssh_key
+
+    def get_cmd_script(self, *args: Any, **kwargs: Any) -> str:
+        cmd_script = self._create_cmd_script(self._cmd_path, self._cmd, *args, **kwargs)
+        cmd_script = "\n".join(
+            [
+                "_SCRIPT=$(cat << 'ENDSCRIPT'",
+                cmd_script,
+                "ENDSCRIPT",
+                ")",
+            ]
         )
+        ssh_command = self._get_ssh_command()
+        return "\n".join([cmd_script, ssh_command])
+
+    def _get_ssh_command(self) -> str:
+        host = self.render_str(self._remote_host)
+        port = self.render_str(self._remote_port)
+        user = self.render_str(self._remote_user)
+        password = self.render_str(self._remote_password)
+        key = self.render_str(self._remote_ssh_key)
+        if key != "" and password != "":
+            return f'sshpass -p "{password}" ssh -t -p "{port}" -i "{key}" "{user}@{host}" "$_SCRIPT"'  # noqa
+        if key != "":
+            return f'ssh -t -p "{port}" -i "{key}" "{user}@{host}" "$_SCRIPT"'
+        if password != "":
+            return f'sshpass -p "{password}" ssh -t -p "{port}" "{user}@{host}" "$_SCRIPT"'  # noqa
+        return f'ssh -t -p "{port}" "{user}@{host}" "$_SCRIPT"'

zrb/task/rsync_task.py

@@ -17,7 +17,6 @@ from zrb.task.any_task_event_handler import (
     OnTriggered,
     OnWaiting,
 )
-from zrb.task.base_remote_cmd_task import BaseRemoteCmdTask, RemoteConfig
 from zrb.task.cmd_task import CmdTask
 from zrb.task_env.env import Env
 from zrb.task_env.env_file import EnvFile
@@ -39,19 +38,17 @@ ensure_rsync_is_installed = CmdTask(
         os.path.join(_SHELL_SCRIPT_DIR, "ensure-rsync-is-installed.sh"),
     ],
     preexec_fn=None,
+    should_print_cmd_result=False,
+    should_show_cmd=False,
+    should_show_working_directory=False,
 )
 
 
 @typechecked
-class RsyncTask(BaseRemoteCmdTask):
+class RsyncTask(CmdTask):
     def __init__(
         self,
         name: str,
-        remote_configs: Iterable[RemoteConfig],
-        src: JinjaTemplate,
-        dst: JinjaTemplate,
-        src_is_remote: bool = False,
-        dst_is_remote: bool = True,
         group: Optional[Group] = None,
         inputs: Iterable[AnyInput] = [],
         envs: Iterable[Env] = [],
@@ -60,7 +57,17 @@ class RsyncTask(BaseRemoteCmdTask):
         color: Optional[str] = None,
         description: str = "",
         executable: Optional[str] = None,
-        cwd: Optional[Union[str, pathlib.Path]] = None,
+        remote_host: JinjaTemplate = "localhost",
+        remote_port: Union[JinjaTemplate, int] = 22,
+        remote_user: JinjaTemplate = "root",
+        remote_password: JinjaTemplate = "",
+        remote_ssh_key: JinjaTemplate = "",
+        src_path: JinjaTemplate = ".",
+        src_is_remote: bool = False,
+        dst_path: JinjaTemplate = ".",
+        dst_is_remote: bool = True,
+        cwd: Optional[Union[JinjaTemplate, pathlib.Path]] = None,
+        should_render_cwd: bool = True,
         upstreams: Iterable[AnyTask] = [],
         fallbacks: Iterable[AnyTask] = [],
         on_triggered: Optional[OnTriggered] = None,
@@ -78,14 +85,14 @@ class RsyncTask(BaseRemoteCmdTask):
         max_error_line: int = 1000,
         preexec_fn: Optional[Callable[[], Any]] = os.setsid,
         should_execute: Union[bool, str, Callable[..., bool]] = True,
+        return_upstream_result: bool = False,
+        should_print_cmd_result: bool = True,
+        should_show_cmd: bool = True,
+        should_show_working_directory: bool = True,
     ):
-        parsed_src = self._get_parsed_path(src_is_remote, src)
-        parsed_dst = self._get_parsed_path(dst_is_remote, dst)
-        cmd = f'auth_rsync "{parsed_src}" "{parsed_dst}"'
-        BaseRemoteCmdTask.__init__(
+        CmdTask.__init__(
             self,
             name=name,
-            remote_configs=remote_configs,
             group=group,
             inputs=inputs,
             envs=envs,
@@ -94,9 +101,8 @@ class RsyncTask(BaseRemoteCmdTask):
             color=color,
             description=description,
             executable=executable,
-            pre_cmd=_RSYNC_UTIL_SCRIPT,
-            cmd=cmd,
             cwd=cwd,
+            should_render_cwd=should_render_cwd,
             upstreams=[ensure_rsync_is_installed] + upstreams,
             fallbacks=fallbacks,
             on_triggered=on_triggered,
@@ -114,9 +120,39 @@ class RsyncTask(BaseRemoteCmdTask):
             max_error_line=max_error_line,
             preexec_fn=preexec_fn,
             should_execute=should_execute,
+            return_upstream_result=return_upstream_result,
+            should_print_cmd_result=should_print_cmd_result,
+            should_show_cmd=should_show_cmd,
+            should_show_working_directory=should_show_working_directory,
         )
+        self._remote_host = remote_host
+        self._remote_port = remote_port
+        self._remote_user = remote_user
+        self._remote_password = remote_password
+        self._remote_ssh_key = remote_ssh_key
+        self._src_path = src_path
+        self._src_is_remote = src_is_remote
+        self._dst_path = dst_path
+        self._dst_is_remote = dst_is_remote
+
+    def get_cmd_script(self, *args: Any, **kwargs: Any) -> str:
+        port = self.render_str(self._remote_port)
+        password = self.render_str(self._remote_password)
+        key = self.render_str(self._remote_ssh_key)
+        src = self._get_path(self._src_path, self._src_is_remote)
+        dst = self._get_path(self._dst_path, self._dst_is_remote)
+        if key != "" and password != "":
+            return f'sshpass -p "{password}" rsync --mkpath -avz -e "ssh -i {key} -p {port}" {src} {dst}'  # noqa
+        if key != "":
+            return f'rsync --mkpath -avz -e "ssh -i {key} -p {port}" {src} {dst}'
+        if password != "":
+            return f'sshpass -p "{password}" rsync --mkpath -avz -e "ssh -p {port}" {src} {dst}'  # noqa
+        return f'rsync --mkpath -avz -e "ssh -p {port}" {src} {dst}'
 
-    def _get_parsed_path(self, is_remote: bool, path: str) -> str:
-        if not is_remote:
-            return path
-        return "${_CONFIG_USER}@${_CONFIG_HOST}:" + path
+    def _get_path(self, resource_path: str, is_remote: bool) -> str:
+        rendered_path = self.render_str(resource_path)
+        if is_remote:
+            host = self.render_str(self._remote_host)
+            user = self.render_str(self._remote_user)
+            return f"{user}@{host}:{rendered_path}"
+        return rendered_path

{zrb-0.26.1.dist-info → zrb-0.27.0.dist-info}/METADATA

@@ -1,10 +1,10 @@
 Metadata-Version: 2.1
 Name: zrb
-Version: 0.26.1
+Version: 0.27.0
 Summary: A Framework to Enhance Your Workflow
 Home-page: https://github.com/state-alchemists/zrb
 License: AGPL-3.0-or-later
-Keywords: Automation,Task Runner,Code Generator,Low Code
+Keywords: Automation,Task Runner,Code Generator,Monorepo,Low Code
 Author: Go Frendi Gunawan
 Author-email: gofrendiasgard@gmail.com
 Requires-Python: >=3.10.0,<4.0.0

{zrb-0.26.1.dist-info → zrb-0.27.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-zrb/__init__.py,sha256=vmWT2ODW6tlhL3hyqOjMT_ezG2fafIK1gZ6G6IBYEgM,2994
+zrb/__init__.py,sha256=dQs1S6z3XbG1BeQ62YYxc6cUs5ejw9T9ajkPgNVEs34,2875
 zrb/__main__.py,sha256=-_k0XOahDF-06n41Uly-oUMkZ8XDSxO-WUUImWz6GiA,171
 zrb/action/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/action/runner.py,sha256=aB46inPOs7CDckfIsS_mlgQ92_bfKltcnb77PjW6Tfw,5179
@@ -87,12 +87,19 @@ zrb/builtin/md5/_group.py,sha256=dimqCmJItc7qx7yRm64tL608oMAjOVXRycP7NTSSFi0,100
 zrb/builtin/md5/hash.py,sha256=futO_5AsXHdS5a7vuBLcgnKCpfEO9UeM-EqaIIBPCZE,572
 zrb/builtin/md5/sum.py,sha256=KZLsXIJrVxvbjyAiVv27-Y2ty-nBRRojsGxXyzQZaYE,688
 zrb/builtin/monorepo/__init__.py,sha256=AgzIDOcrW4FXxly5SqExyGRo-fIo0ocX_fCScLPDuR0,239
+zrb/builtin/monorepo/_common.sh,sha256=HfSIyw_OYGXx0TZzwdLB21fX6sTnZ_45Vf6YXVxxU-k,336
 zrb/builtin/monorepo/_config.py,sha256=cTKOoDonkVXR-1SGUYtA8d5aUpDkhN4olhPQwfJhV4U,365
 zrb/builtin/monorepo/_group.py,sha256=idv_8MIE-TCNAvhE0urh7OxTx3qNZbBlE9wYJ-teqa8,115
-zrb/builtin/monorepo/_task.py,sha256=6KKlC1COqbv1fIfd7lT1GTg8zY0knFzwlbpkgf2OZpE,3382
+zrb/builtin/monorepo/_helper.py,sha256=RuK0mkQI73ryixD_iYfp8lxJmrFxkHyFvDThW2fsrF8,4057
+zrb/builtin/monorepo/_task.py,sha256=1UY8eErrjpykK51UjjIu74lH25jMW8l3k36-eyYk9KI,3869
+zrb/builtin/monorepo/add-subrepo.sh,sha256=LWyie9_3aCA7OarzDl7HedJnV7OpkkSHUHHPDcToNQ8,426
 zrb/builtin/monorepo/add.py,sha256=MtPhTEJEdpfRsbdB-hln4hyGzPVWu9kdrmiCxqu0dTs,1580
-zrb/builtin/monorepo/pull.py,sha256=2wIrz1D6OJmuBkdVbWRDXUiz8W4aLo3GC601_ASVAb8,702
-zrb/builtin/monorepo/push.py,sha256=ZvFHfOTVqSUj7gQ3D8mc19tdIoTz4gG2Iv6kui0neu8,1083
+zrb/builtin/monorepo/pull-monorepo.sh,sha256=80mC-FOmIFjhgeGe_s6SzKgf5ZyUwrUsz8O1huTP3Ww,377
+zrb/builtin/monorepo/pull-subrepo.sh,sha256=7M6haXVkApuS3F1Ndp-jrdRMLbPbSYZUo7ckVAffypI,365
+zrb/builtin/monorepo/pull.py,sha256=6W9w2QJipn9TYIqaE-tzW_KK1hxPU7oJW0IlH_yPwJA,676
+zrb/builtin/monorepo/push-monorepo.sh,sha256=qkr6vfIvIKSKCiE1rartU5vahcjP7Ocvrt-zhgc1ZSo,346
+zrb/builtin/monorepo/push-subrepo.sh,sha256=k-9ZbEEwDOgHn9Jo_CSkZwk4-bkcZm4TUc-e6j8Kvlk,353
+zrb/builtin/monorepo/push.py,sha256=snKu4ravGFBBxHwLegI_kg65a9sG8bpf7t2T2CanNcE,668
 zrb/builtin/process/__init__.py,sha256=dWM1zIehY65rkJvEAFvX6HGJHL8kb1gkzaSz0Woay8M,283
 zrb/builtin/process/_group.py,sha256=KY7iQ_pvqe5iVsRFeLWs-O-xuSyqlTXVj47_TCnu7zQ,118
 zrb/builtin/process/pid/__init__.py,sha256=Rcb3bYgR_oVNOlaggYjcRipHRehrumZuQyadrguXdR0,293
@@ -1386,9 +1393,8 @@ zrb/shell-scripts/ssh-util.sh,sha256=9lXDzw6oO8HuA4vdbfps_uQMMwKyNYX9fZkZgpK52g8
 zrb/task/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/task/any_task.py,sha256=SlAp6LY-8TGopaQm3eZD3ZEx3wxvCff8UfcnYyu-aiY,39344
 zrb/task/any_task_event_handler.py,sha256=ay4v7eXatF4sCiXpUYaHVJZljpnKlvBbFIwvZqXW8Mo,541
-zrb/task/base_remote_cmd_task.py,sha256=EhAT7grnIxFeMfwm8FV6GF6n0kOYESAyIIVzqgZBRBg,12324
 zrb/task/base_task/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-zrb/task/base_task/base_task.py,sha256=mHTgXmGROkGZw97HLpk-XE5lfhDL0jYyX9okaOTZgxY,20439
+zrb/task/base_task/base_task.py,sha256=oihVRUHAvNMwlfLEWQoixt5OwyMLyW9w6bSGD9WGVIk,20457
 zrb/task/base_task/component/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/task/base_task/component/base_task_model.py,sha256=EuTWvY54mD_ATy4-VFZw4uCOu3Mfe8hgZikwTnIjmkY,10381
 zrb/task/base_task/component/common_task_model.py,sha256=X_Ubu5kNycQJ-dFiLMARvC6GWQ9pIjBCdxh3MVelc-A,13544
@@ -1399,8 +1405,8 @@ zrb/task/checker.py,sha256=mh_2ajZqpNdJQ8AFVQ6ZArYtBUOXST3aZSisINuEivk,3400
 zrb/task/cmd_task.py,sha256=B3kRtpb0QVjusPWAMLjpfGxvAdEfgD9_N0jiU55S3rA,14718
 zrb/task/decorator.py,sha256=SuajollezbwiSOs29bv8A6PmFcFs_RH4pr4TPcQPDHM,3081
 zrb/task/docker_compose_start_task.py,sha256=n4mLejebyy8sF4rbcfWZucPcBiqPSkDAdGZvOhk4Xt8,5335
-zrb/task/docker_compose_task.py,sha256=QGJ-jlD0jCKIb5avzri1Z29zdIL3Cn6m4kaEOko3U6M,15615
-zrb/task/flow_task.py,sha256=RPci5Inc_QImq9sYI3SnDODeqMtwhO2DA7axbFoZPEQ,5158
+zrb/task/docker_compose_task.py,sha256=NuNevzooQVn3wgMNrBBdVD2FepRpE38ouYkRNXeqQ2s,15543
+zrb/task/flow_task.py,sha256=wkvvUCrt6n1ul-o3STCPMdrlBuGBrNCRgtRzGyXir9o,5079
 zrb/task/http_checker.py,sha256=gXqBlEStMnIhzmQ7FX9Zo-nG3-wsiVEML8IOJiSG5JI,5705
 zrb/task/looper.py,sha256=zInLRgcQlReGXz4Ffxc2W99RovSChj6kHuGEGmaPb-Q,1432
 zrb/task/notifier.py,sha256=xjqT5Vydr_0cc1m4jA-odhHMZg6CSGciFCs0rhVkvPM,6265
@@ -1409,9 +1415,9 @@ zrb/task/path_checker.py,sha256=xkOpxlLUaEXlsiWh1o-ghqQNWYadXvTl3QV4yeIC2Rc,4677
 zrb/task/path_watcher.py,sha256=aKWhT7Kuc_UJMr8SSY7ZZym-_rV526tEeIaKRRz3XYU,7419
 zrb/task/port_checker.py,sha256=SG2yrAxdJgxdR6xymviB48K529o3Rnq_WhDJZDKgAQg,4605
 zrb/task/recurring_task.py,sha256=wtZhi0DCDdVM7ecIgoXghQPTOQemrEvCY8xDJoaG1mo,7444
-zrb/task/remote_cmd_task.py,sha256=jl4lcAiRwy30H-wGVJr4111xGZ7n3p0cTL2zRPi8dqY,3970
+zrb/task/remote_cmd_task.py,sha256=LQxDoFxd6Z-ALQqgDOntenaqABzQ5ri1sHTOKwb2-WQ,5801
 zrb/task/resource_maker.py,sha256=e6nmFJsVHHo8_sW5F-lBfkO_2RszrlXNoubh4rwM6UY,7644
-zrb/task/rsync_task.py,sha256=qu5vyQUIkypgLH-974qICNtjs3ZGg3Cp1e904kxs44I,4235
+zrb/task/rsync_task.py,sha256=gryXNikhsJ4BXU3XzK15xF4KDUXAH8ydO36JdUwER-c,6034
 zrb/task/server.py,sha256=zC8swQOu_3YkRtGFXuRGZqz6yEu--ZhNRgNwbR44uUA,6741
 zrb/task/task.py,sha256=iHDyUMUh1uVGlMCQdVewdT3epCOHKNRKblC3G1WSKS0,2493
 zrb/task/time_watcher.py,sha256=v01whCMTvul_vraVccy8A9rDBk-CL7HFvPOu8g1BC5s,5130
@@ -1434,8 +1440,8 @@ zrb/task_input/multiline_input.py,sha256=KNto5k5X1C6KE_A-vX0OjpQyjgCRJ6BR2PwHXNQ
 zrb/task_input/password_input.py,sha256=95NlJ9xIq7z_evpAyR2XsBpeuWpBXd2Ezn3P7oDOttk,4360
 zrb/task_input/str_input.py,sha256=0nje7vI9fs_xqQBbmKB8Yn7wevlWp9Qebv7f8-GmiXs,4350
 zrb/task_input/task_input.py,sha256=WTj_qIQyRs-04-VotjNTcVyIuf6b2afInVoCQHoRmr0,2327
-zrb-0.26.1.dist-info/LICENSE,sha256=WfnGCl8G60EYOPAEkuc8C9m9pdXWDe08NsKj3TBbxsM,728
-zrb-0.26.1.dist-info/METADATA,sha256=13sVwksJgQqxQn6tNs5nuZm0l_kFO6XgiHfjaP91O28,17085
-zrb-0.26.1.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-zrb-0.26.1.dist-info/entry_points.txt,sha256=xTgXc1kBKYhJHEujdaSPHUcJT3-hbyP1mLgwkv-5sSk,40
-zrb-0.26.1.dist-info/RECORD,,
+zrb-0.27.0.dist-info/LICENSE,sha256=WfnGCl8G60EYOPAEkuc8C9m9pdXWDe08NsKj3TBbxsM,728
+zrb-0.27.0.dist-info/METADATA,sha256=TPjzJNyVNVgFbcSDdhyJfNhbtYoGW2WXl72M1YqS8wE,17094
+zrb-0.27.0.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+zrb-0.27.0.dist-info/entry_points.txt,sha256=xTgXc1kBKYhJHEujdaSPHUcJT3-hbyP1mLgwkv-5sSk,40
+zrb-0.27.0.dist-info/RECORD,,

zrb/task/base_remote_cmd_task.py

@@ -1,354 +0,0 @@
-import os
-import pathlib
-from collections.abc import Callable, Iterable, Mapping
-from typing import Any, Optional, TypeVar, Union
-
-from zrb.helper.accessories.color import colored
-from zrb.helper.log import logger
-from zrb.helper.typecheck import typechecked
-from zrb.helper.typing import JinjaTemplate
-from zrb.helper.util import to_snake_case
-from zrb.task.any_task import AnyTask
-from zrb.task.any_task_event_handler import (
-    OnFailed,
-    OnReady,
-    OnRetry,
-    OnSkipped,
-    OnStarted,
-    OnTriggered,
-    OnWaiting,
-)
-from zrb.task.base_task.base_task import BaseTask
-from zrb.task.cmd_task import CmdTask, CmdVal
-from zrb.task_env.env import Env
-from zrb.task_env.env_file import EnvFile
-from zrb.task_group.group import Group
-from zrb.task_input.any_input import AnyInput
-
-logger.debug(colored("Loading zrb.task.base_remote_cmd_task", attrs=["dark"]))
-
-TSingleBaseRemoteCmdTask = TypeVar(
-    "TSingleBaseRemoteCmdTask", bound="SingleBaseRemoteCmdTask"
-)
-TBaseRemoteCmdTask = TypeVar("TBaseRemoteCmdTask", bound="BaseRemoteCmdTask")
-
-
-@typechecked
-class RemoteConfig:
-    def __init__(
-        self,
-        host: JinjaTemplate,
-        user: JinjaTemplate = "",
-        password: JinjaTemplate = "",
-        ssh_key: JinjaTemplate = "",
-        port: Union[int, JinjaTemplate] = 22,
-        name: Optional[str] = None,
-        config_map: Optional[Mapping[str, JinjaTemplate]] = None,
-    ):
-        self.name = name if name is not None else host
-        self.host = host
-        self.user = user
-        self.password = password
-        self.ssh_key = ssh_key
-        self.port = port
-        self.config_map = {} if config_map is None else config_map
-
-
-@typechecked
-class SingleBaseRemoteCmdTask(CmdTask):
-    def __init__(
-        self,
-        name: str,
-        remote_config: RemoteConfig,
-        group: Optional[Group] = None,
-        inputs: Iterable[AnyInput] = [],
-        envs: Iterable[Env] = [],
-        env_files: Iterable[EnvFile] = [],
-        icon: Optional[str] = None,
-        color: Optional[str] = None,
-        description: str = "",
-        executable: Optional[str] = None,
-        pre_cmd: CmdVal = "",
-        pre_cmd_path: CmdVal = "",
-        cmd: CmdVal = "",
-        cmd_path: CmdVal = "",
-        post_cmd: CmdVal = "",
-        post_cmd_path: CmdVal = "",
-        cwd: Optional[Union[str, pathlib.Path]] = None,
-        should_render_cwd: bool = True,
-        upstreams: Iterable[AnyTask] = [],
-        fallbacks: Iterable[AnyTask] = [],
-        on_triggered: Optional[OnTriggered] = None,
-        on_waiting: Optional[OnWaiting] = None,
-        on_skipped: Optional[OnSkipped] = None,
-        on_started: Optional[OnStarted] = None,
-        on_ready: Optional[OnReady] = None,
-        on_retry: Optional[OnRetry] = None,
-        on_failed: Optional[OnFailed] = None,
-        checkers: Iterable[AnyTask] = [],
-        checking_interval: Union[float, int] = 0.05,
-        retry: int = 2,
-        retry_interval: Union[float, int] = 1,
-        max_output_line: int = 1000,
-        max_error_line: int = 1000,
-        preexec_fn: Optional[Callable[[], Any]] = os.setsid,
-        should_execute: Union[bool, str, Callable[..., bool]] = True,
-        return_upstream_result: bool = False,
-        should_print_cmd_result: bool = True,
-        should_show_cmd: bool = True,
-        should_show_working_directory: bool = True,
-    ):
-        CmdTask.__init__(
-            self,
-            name=name,
-            group=group,
-            inputs=inputs,
-            envs=envs,
-            env_files=env_files,
-            icon=icon,
-            color=color,
-            description=description,
-            executable=executable,
-            cmd=cmd,
-            cmd_path=cmd_path,
-            cwd=cwd,
-            should_render_cwd=should_render_cwd,
-            upstreams=upstreams,
-            fallbacks=fallbacks,
-            on_triggered=on_triggered,
-            on_waiting=on_waiting,
-            on_skipped=on_skipped,
-            on_started=on_started,
-            on_ready=on_ready,
-            on_retry=on_retry,
-            on_failed=on_failed,
-            checkers=checkers,
-            checking_interval=checking_interval,
-            retry=retry,
-            retry_interval=retry_interval,
-            max_output_line=max_output_line,
-            max_error_line=max_error_line,
-            preexec_fn=preexec_fn,
-            should_execute=should_execute,
-            return_upstream_result=return_upstream_result,
-            should_print_cmd_result=should_print_cmd_result,
-            should_show_cmd=should_show_cmd,
-            should_show_working_directory=should_show_working_directory,
-        )
-        self._pre_cmd = pre_cmd
-        self._pre_cmd_path = pre_cmd_path
-        self._post_cmd = post_cmd
-        self._post_cmd_path = post_cmd_path
-        self._remote_config = remote_config
-
-    def copy(self) -> TSingleBaseRemoteCmdTask:
-        return super().copy()
-
-    def inject_envs(self):
-        super().inject_envs()
-        # add remote config properties as env
-        self.add_env(
-            Env(
-                name="_CONFIG_HOST",
-                os_name="",
-                default=self.render_str(self._remote_config.host),
-            ),
-            Env(
-                name="_CONFIG_PORT",
-                os_name="",
-                default=str(self.render_int(self._remote_config.port)),
-            ),
-            Env(
-                name="_CONFIG_SSH_KEY",
-                os_name="",
-                default=self.render_str(self._remote_config.ssh_key),
-            ),
-            Env(
-                name="_CONFIG_USER",
-                os_name="",
-                default=self.render_str(self._remote_config.user),
-            ),
-            Env(
-                name="_CONFIG_PASSWORD",
-                os_name="",
-                default=self.render_str(self._remote_config.password),
-            ),
-        )
-        for key, val in self._remote_config.config_map.items():
-            upper_snake_key = to_snake_case(key).upper()
-            rendered_val = self.render_str(val)
-            # add remote config map as env
-            self.add_env(
-                Env(
-                    name="_CONFIG_MAP_" + upper_snake_key,
-                    os_name="",
-                    default=rendered_val,
-                )
-            )
-
-    def get_cmd_script(self, *args: Any, **kwargs: Any) -> str:
-        cmd_str = "\n".join(
-            [
-                self._create_cmd_script(
-                    self._pre_cmd_path, self._pre_cmd, *args, **kwargs
-                ),
-                super().get_cmd_script(*args, **kwargs),
-                self._create_cmd_script(
-                    self._post_cmd_path, self._post_cmd, *args, **kwargs
-                ),
-            ]
-        )
-        return cmd_str
-
-
-@typechecked
-class BaseRemoteCmdTask(BaseTask):
-    def __init__(
-        self,
-        name: str,
-        remote_configs: Iterable[RemoteConfig],
-        group: Optional[Group] = None,
-        inputs: Iterable[AnyInput] = [],
-        envs: Iterable[Env] = [],
-        env_files: Iterable[EnvFile] = [],
-        icon: Optional[str] = None,
-        color: Optional[str] = None,
-        description: str = "",
-        executable: Optional[str] = None,
-        pre_cmd: CmdVal = "",
-        pre_cmd_path: CmdVal = "",
-        cmd: CmdVal = "",
-        cmd_path: CmdVal = "",
-        post_cmd: CmdVal = "",
-        post_cmd_path: CmdVal = "",
-        cwd: Optional[Union[JinjaTemplate, pathlib.Path]] = None,
-        should_render_cwd: bool = True,
-        upstreams: Iterable[AnyTask] = [],
-        fallbacks: Iterable[AnyTask] = [],
-        on_triggered: Optional[OnTriggered] = None,
-        on_waiting: Optional[OnWaiting] = None,
-        on_skipped: Optional[OnSkipped] = None,
-        on_started: Optional[OnStarted] = None,
-        on_ready: Optional[OnReady] = None,
-        on_retry: Optional[OnRetry] = None,
-        on_failed: Optional[OnFailed] = None,
-        checkers: Iterable[AnyTask] = [],
-        checking_interval: Union[float, int] = 0.05,
-        retry: int = 2,
-        retry_interval: Union[float, int] = 1,
-        max_output_line: int = 1000,
-        max_error_line: int = 1000,
-        preexec_fn: Optional[Callable[[], Any]] = os.setsid,
-        should_execute: Union[bool, str, Callable[..., bool]] = True,
-        return_upstream_result: bool = False,
-        should_print_cmd_result: bool = True,
-        should_show_cmd: bool = True,
-        should_show_working_directory: bool = True,
-    ):
-        self._remote_configs = list(remote_configs)
-        self._sub_tasks = [
-            SingleBaseRemoteCmdTask(
-                name=f"{name}-{remote_config.name}",
-                remote_config=remote_config,
-                inputs=inputs,
-                envs=envs,
-                env_files=env_files,
-                description=description,
-                executable=executable,
-                pre_cmd=pre_cmd,
-                pre_cmd_path=pre_cmd_path,
-                cmd=cmd,
-                cmd_path=cmd_path,
-                post_cmd=post_cmd,
-                post_cmd_path=post_cmd_path,
-                cwd=cwd,
-                should_render_cwd=should_render_cwd,
-                upstreams=upstreams,
-                fallbacks=fallbacks,
-                on_triggered=on_triggered,
-                on_waiting=on_waiting,
-                on_skipped=on_skipped,
-                on_started=on_started,
-                on_ready=on_ready,
-                on_retry=on_retry,
-                on_failed=on_failed,
-                checkers=checkers,
-                checking_interval=checking_interval,
-                retry=retry,
-                retry_interval=retry_interval,
-                max_output_line=max_output_line,
-                max_error_line=max_error_line,
-                preexec_fn=preexec_fn,
-                should_execute=should_execute,
-                return_upstream_result=return_upstream_result,
-                should_print_cmd_result=should_print_cmd_result,
-                should_show_cmd=should_show_cmd,
-                should_show_working_directory=should_show_working_directory,
-            )
-            for remote_config in self._remote_configs
-        ]
-        BaseTask.__init__(
-            self,
-            name=name,
-            icon=icon,
-            color=color,
-            group=group,
-            description=description,
-            upstreams=self._sub_tasks,
-            retry=0,
-            return_upstream_result=True,
-        )
-
-    def insert_input(self, *inputs: AnyInput):
-        super().insert_input(*inputs)
-        for subtask in self._sub_tasks:
-            subtask.insert_input(*inputs)
-
-    def add_input(self, *inputs: AnyInput):
-        super().add_input(*inputs)
-        for subtask in self._sub_tasks:
-            subtask.add_input(*inputs)
-
-    def insert_env(self, *envs: Env):
-        super().insert_env(*envs)
-        for subtask in self._sub_tasks:
-            subtask.insert_env(*envs)
-
-    def add_env(self, *envs: Env):
-        super().add_env(*envs)
-        for subtask in self._sub_tasks:
-            subtask.add_env(*envs)
-
-    def insert_env_file(self, *env_files: EnvFile):
-        super().insert_env_file(*env_files)
-        for subtask in self._sub_tasks:
-            subtask.insert_env_file(*env_files)
-
-    def add_env_file(self, *env_files: Env):
-        super().add_env_file(*env_files)
-        for subtask in self._sub_tasks:
-            subtask.add_env_file(*env_files)
-
-    def insert_upstream(self, *upstreams: AnyTask):
-        for subtask in self._sub_tasks:
-            subtask.insert_upstream(*upstreams)
-
-    def add_upstream(self, *upstreams: AnyTask):
-        for subtask in self._sub_tasks:
-            subtask.add_upstream(*upstreams)
-
-    def insert_fallback(self, *fallbacks: AnyTask):
-        for subtask in self._sub_tasks:
-            subtask.insert_fallbacks(*fallbacks)
-
-    def add_fallback(self, *fallbacks: AnyTask):
-        for subtask in self._sub_tasks:
-            subtask.add_fallback(*fallbacks)
-
-    def insert_checker(self, *checkers: AnyTask):
-        for subtask in self._sub_tasks:
-            subtask.insert_checkers(*checkers)
-
-    def add_checker(self, *checkers: AnyTask):
-        for subtask in self._sub_tasks:
-            subtask.add_checker(*checkers)