zrb 0.26.2__py3-none-any.whl → 0.27.1__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/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/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,9 +17,8 @@ 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 import Env, PrivateEnv
 from zrb.task_env.env_file import EnvFile
 from zrb.task_group.group import Group
 from zrb.task_input.any_input import AnyInput
@@ -27,8 +27,6 @@ logger.debug(colored("Loading zrb.task.remote_cmd_task", attrs=["dark"]))
 
 _CURRENT_DIR = os.path.dirname(__file__)
 _SHELL_SCRIPT_DIR = os.path.join(_CURRENT_DIR, "..", "shell-scripts")
-with open(os.path.join(_SHELL_SCRIPT_DIR, "ssh-util.sh")) as file:
-    _SSH_UTIL_SCRIPT = file.read()
 
 ensure_ssh_is_installed = CmdTask(
     name="ensure-ssh-is-installed",
@@ -37,15 +35,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 +54,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,31 +80,26 @@ 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,
+            envs=envs + [PrivateEnv(name="_ZRB_SSH_PASSWORD", default=remote_password)],
             env_files=env_files,
             icon=icon,
             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 +117,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 "$_ZRB_SSH_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 "$_ZRB_SSH_PASSWORD" ssh -t -p "{port}" "{user}@{host}" "$_SCRIPT"'  # noqa
+        return f'ssh -t -p "{port}" "{user}@{host}" "$_SCRIPT"'

zrb/task/rsync_task.py

@@ -17,9 +17,8 @@ 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 import Env, PrivateEnv
 from zrb.task_env.env_file import EnvFile
 from zrb.task_group.group import Group
 from zrb.task_input.any_input import AnyInput
@@ -28,8 +27,6 @@ logger.debug(colored("Loading zrb.task.rsync_task", attrs=["dark"]))
 
 _CURRENT_DIR = os.path.dirname(__file__)
 _SHELL_SCRIPT_DIR = os.path.join(_CURRENT_DIR, "..", "shell-scripts")
-with open(os.path.join(_SHELL_SCRIPT_DIR, "rsync-util.sh")) as file:
-    _RSYNC_UTIL_SCRIPT = file.read()
 
 ensure_rsync_is_installed = CmdTask(
     name="ensure-ssh-is-installed",
@@ -39,19 +36,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 +55,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,25 +83,24 @@ 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,
+            envs=envs + [PrivateEnv(name="_ZRB_SSH_PASSWORD", default=remote_password)],
             env_files=env_files,
             icon=icon,
             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 +118,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 "$_ZRB_SSH_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 "$_ZRB_SSH_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.2.dist-info → zrb-0.27.1.dist-info}/METADATA

@@ -1,10 +1,10 @@
 Metadata-Version: 2.1
 Name: zrb
-Version: 0.26.2
+Version: 0.27.1
 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.2.dist-info → zrb-0.27.1.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
@@ -1388,12 +1388,9 @@ zrb/shell-scripts/ensure-podman-is-installed.sh,sha256=RvLLQIBN5cfLEsFkTpomgl_Px
 zrb/shell-scripts/ensure-rsync-is-installed.sh,sha256=ffr8avoCUSoDQkEBWmeelgn-EtF9reQTaM0wfW6B0hc,1146
 zrb/shell-scripts/ensure-ssh-is-installed.sh,sha256=w5pCzsbEa3bnxT07q6gX0nWn-7HXsMiwBRrg7dMD57w,2414
 zrb/shell-scripts/notify.ps1,sha256=6_xPoIwuxARpYljcjVV-iRJS3gJqGfx-B6kj719cJ9o,843
-zrb/shell-scripts/rsync-util.sh,sha256=QzdhSBvUNMxB4U2B4m0Dxg9czGckRjB7Vk4A1ObG0-k,353
-zrb/shell-scripts/ssh-util.sh,sha256=9lXDzw6oO8HuA4vdbfps_uQMMwKyNYX9fZkZgpK52g8,401
 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=oihVRUHAvNMwlfLEWQoixt5OwyMLyW9w6bSGD9WGVIk,20457
 zrb/task/base_task/component/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -1406,7 +1403,7 @@ 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/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
@@ -1416,9 +1413,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=-kNkRVSIDrNJcVRBfMpc-fXYOHh6Fs2PTsiOzWwimTM,5793
 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=NdfKtendGyH9Kg17hEsavl1NoeIJ04FTii2OaXg_S6g,6022
 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
@@ -1441,8 +1438,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.2.dist-info/LICENSE,sha256=WfnGCl8G60EYOPAEkuc8C9m9pdXWDe08NsKj3TBbxsM,728
-zrb-0.26.2.dist-info/METADATA,sha256=-wlbBUk5VeBxb07XicBQtuBGBnUwDhCGYR1pfZwVUmE,17085
-zrb-0.26.2.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-zrb-0.26.2.dist-info/entry_points.txt,sha256=xTgXc1kBKYhJHEujdaSPHUcJT3-hbyP1mLgwkv-5sSk,40
-zrb-0.26.2.dist-info/RECORD,,
+zrb-0.27.1.dist-info/LICENSE,sha256=WfnGCl8G60EYOPAEkuc8C9m9pdXWDe08NsKj3TBbxsM,728
+zrb-0.27.1.dist-info/METADATA,sha256=-ckE3NSw1Xels6NSJMCI3kRdv55-x21CTF9UE6LpdiM,17094
+zrb-0.27.1.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+zrb-0.27.1.dist-info/entry_points.txt,sha256=xTgXc1kBKYhJHEujdaSPHUcJT3-hbyP1mLgwkv-5sSk,40
+zrb-0.27.1.dist-info/RECORD,,

zrb/shell-scripts/rsync-util.sh

@@ -1,12 +0,0 @@
-set -e
-auth_rsync(){
-    if [ "$_CONFIG_SSH_KEY" != "" ]
-    then
-        rsync --mkpath -avz -e "ssh -i $_CONFIG_SSH_KEY -p $_CONFIG_PORT" $@
-    elif [ "$_CONFIG_PASSWORD" != "" ]
-    then
-        sshpass -p "$_CONFIG_PASSWORD" rsync --mkpath -avz -e "ssh -p $_CONFIG_PORT" $@
-    else
-        rsync --mkpath -avz -e "ssh -p $_CONFIG_PORT" $@
-    fi
-}

zrb/shell-scripts/ssh-util.sh

@@ -1,12 +0,0 @@
-set -e
-auth_ssh(){
-    if [ "$_CONFIG_SSH_KEY" != "" ]
-    then
-        ssh -t -p "$_CONFIG_PORT" -i "$_CONFIG_SSH_KEY" "${_CONFIG_USER}@${_CONFIG_HOST}" "$1"
-    elif [ "$_CONFIG_PASSWORD" != "" ]
-    then
-        sshpass -p "$_CONFIG_PASSWORD" ssh -t -p "$_CONFIG_PORT" "${_CONFIG_USER}@${_CONFIG_HOST}" "$1"
-    else
-        ssh -t -p "$_CONFIG_PORT" "${_CONFIG_USER}@${_CONFIG_HOST}" "$1"
-    fi
-}

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)