zrb 0.28.1__py3-none-any.whl → 1.0.0a1__py3-none-any.whl

zrb/task/path_watcher.py

@@ -1,199 +0,0 @@
-import os
-from collections.abc import Callable, Iterable, Mapping
-from typing import Any, Optional, TypeVar, Union
-
-from zrb.helper.accessories.color import colored
-from zrb.helper.file.match import get_file_names
-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,
-    OnReady,
-    OnRetry,
-    OnSkipped,
-    OnStarted,
-    OnTriggered,
-    OnWaiting,
-)
-from zrb.task.watcher import Watcher
-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.path_watcher", attrs=["dark"]))
-
-TPathWatcher = TypeVar("TPathWatcher", bound="PathWatcher")
-
-
-@typechecked
-class PathWatcher(Watcher):
-    """
-    PathWatcher will wait for any changes specified on  path.
-
-    Once the changes detected, PathWatcher will be completed
-    and several xcom will be set:
-    - <task-name>.file
-    - <task-name>.new-file
-    - <task-name>.modified-file
-    - <task-name>.deleted-file
-    """
-
-    __init_times: Mapping[str, Mapping[str, float]] = {}
-
-    def __init__(
-        self,
-        name: str = "watch-path",
-        group: Optional[Group] = None,
-        inputs: Iterable[AnyInput] = [],
-        envs: Iterable[Env] = [],
-        env_files: Iterable[EnvFile] = [],
-        icon: Optional[str] = None,
-        color: Optional[str] = None,
-        description: str = "",
-        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,
-        path: JinjaTemplate = "",
-        ignored_path: Union[JinjaTemplate, Iterable[JinjaTemplate]] = [],
-        checking_interval: Union[int, float] = 0.05,
-        progress_interval: Union[int, float] = 30,
-        watch_new_files: bool = True,
-        watch_modified_files: bool = True,
-        watch_deleted_files: bool = True,
-        should_execute: Union[bool, JinjaTemplate, Callable[..., bool]] = True,
-    ):
-        Watcher.__init__(
-            self,
-            name=name,
-            group=group,
-            inputs=inputs,
-            envs=envs,
-            env_files=env_files,
-            icon=icon,
-            color=color,
-            description=description,
-            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,
-            checking_interval=checking_interval,
-            progress_interval=progress_interval,
-            should_execute=should_execute,
-        )
-        self._path = path
-        self._ignored_path = ignored_path
-        self._watch_new_files = watch_new_files
-        self._watch_modified_files = watch_modified_files
-        self._watch_deleted_files = watch_deleted_files
-        self._rendered_path: str = ""
-        self._rendered_ignored_paths: list[str] = []
-
-    def copy(self) -> TPathWatcher:
-        return super().copy()
-
-    def to_function(
-        self,
-        env_prefix: str = "",
-        raise_error: bool = True,
-        is_async: bool = False,
-        show_done_info: bool = True,
-        should_clear_xcom: bool = False,
-        should_stop_looper: bool = False,
-    ) -> Callable[..., bool]:
-        return super().to_function(
-            env_prefix=env_prefix,
-            raise_error=raise_error,
-            is_async=is_async,
-            show_done_info=show_done_info,
-            should_clear_xcom=should_clear_xcom,
-            should_stop_looper=should_stop_looper,
-        )
-
-    async def run(self, *args: Any, **kwargs: Any) -> bool:
-        self._rendered_path = self.render_str(self._path)
-        self._rendered_ignored_paths = [
-            ignored_path
-            for ignored_path in self._get_rendered_ignored_paths()
-            if ignored_path != ""
-        ]
-        identifier = self.get_identifier()
-        if identifier not in self.__init_times:
-            self.__init_times[identifier] = self._get_mod_times()
-        return await super().run(*args, **kwargs)
-
-    def _get_rendered_ignored_paths(self) -> list[str]:
-        if isinstance(self._ignored_path, str):
-            return [self.render_str(self._ignored_path)]
-        return [self.render_str(ignored_path) for ignored_path in self._ignored_path]
-
-    def create_loop_inspector(self) -> Callable[..., Optional[bool]]:
-        def loop_inspect() -> bool:
-            label = f"Watching {self._rendered_path}"
-            identifier = self.get_identifier()
-            try:
-                init_times = self.__init_times[identifier]
-                mod_times = self._get_mod_times()
-            except Exception as e:
-                self.show_progress(f"{label} Cannot inspect")
-                raise e
-            # watch changes
-            if self._watch_new_files:
-                new_files = mod_times.keys() - init_times.keys()
-                for file in new_files:
-                    self.print_out_dark(f"{label} [+] New file detected: {file}")
-                    self.set_task_xcom("new-file", file)
-                    self.set_task_xcom("file", file)
-                    self.__init_times[identifier] = self._get_mod_times()
-                    return True
-            if self._watch_deleted_files:
-                deleted_files = init_times.keys() - mod_times.keys()
-                for file in deleted_files:
-                    self.print_out_dark(f"{label} [-] File deleted: {file}")
-                    self.set_task_xcom("deleted-file", file)
-                    self.set_task_xcom("file", file)
-                    self.__init_times[identifier] = self._get_mod_times()
-                    return True
-            if self._watch_modified_files:
-                modified_files = {
-                    file
-                    for file, mod_time in mod_times.items()
-                    if file in mod_times and init_times[file] != mod_time
-                }
-                for file in modified_files:
-                    self.print_out_dark(f"{label} [/] File modified: {file}")
-                    self.set_task_xcom("modified-file", file)
-                    self.set_task_xcom("file", file)
-                    self.__init_times[identifier] = self._get_mod_times()
-                    return True
-            self.show_progress(f"{label} (Nothing changed)")
-            return False
-
-        return loop_inspect
-
-    def _get_mod_times(self) -> Mapping[str, float]:
-        matches = get_file_names(
-            glob_path=self._rendered_path,
-            glob_ignored_paths=self._rendered_ignored_paths,
-        )
-        mod_times: Mapping[str, float] = {}
-        for file_name in matches:
-            try:
-                mod_time = os.stat(file_name).st_mtime
-                mod_times[file_name] = mod_time
-            except Exception as e:
-                self.print_err(e)
-        return mod_times

zrb/task/port_checker.py

@@ -1,137 +0,0 @@
-import socket
-from collections.abc import Callable, Iterable
-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.task.any_task import AnyTask
-from zrb.task.any_task_event_handler import (
-    OnFailed,
-    OnReady,
-    OnRetry,
-    OnSkipped,
-    OnStarted,
-    OnTriggered,
-    OnWaiting,
-)
-from zrb.task.checker import Checker
-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.port_checker", attrs=["dark"]))
-
-TPortChecker = TypeVar("TPortChecker", bound="PortChecker")
-
-
-@typechecked
-class PortConfig:
-    def __init__(self, host: str, port: int, timeout: int):
-        self.host = host
-        self.port = port
-        self.timeout = timeout
-        self.label = f"Checking {host}:{port}"
-
-
-@typechecked
-class PortChecker(Checker):
-    def __init__(
-        self,
-        name: str = "check-port",
-        group: Optional[Group] = None,
-        inputs: Iterable[AnyInput] = [],
-        envs: Iterable[Env] = [],
-        env_files: Iterable[EnvFile] = [],
-        icon: Optional[str] = None,
-        color: Optional[str] = None,
-        description: str = "",
-        host: JinjaTemplate = "localhost",
-        port: Union[int, JinjaTemplate] = 80,
-        timeout: Union[int, JinjaTemplate] = 5,
-        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,
-        checking_interval: Union[int, float] = 0.05,
-        progress_interval: Union[int, float] = 5,
-        expected_result: bool = True,
-        should_execute: Union[bool, str, Callable[..., bool]] = True,
-    ):
-        Checker.__init__(
-            self,
-            name=name,
-            group=group,
-            inputs=inputs,
-            envs=envs,
-            env_files=env_files,
-            icon=icon,
-            color=color,
-            description=description,
-            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,
-            checking_interval=checking_interval,
-            progress_interval=progress_interval,
-            expected_result=expected_result,
-            should_execute=should_execute,
-        )
-        self._host = host
-        self._port = port
-        self._timeout = timeout
-        self._config: Optional[PortChecker] = None
-
-    def copy(self) -> TPortChecker:
-        return super().copy()
-
-    def to_function(
-        self,
-        env_prefix: str = "",
-        raise_error: bool = True,
-        is_async: bool = False,
-        show_done_info: bool = True,
-        should_clear_xcom: bool = False,
-        should_stop_looper: bool = False,
-    ) -> Callable[..., bool]:
-        return super().to_function(
-            env_prefix=env_prefix,
-            raise_error=raise_error,
-            is_async=is_async,
-            show_done_info=show_done_info,
-            should_clear_xcom=should_clear_xcom,
-            should_stop_looper=should_stop_looper,
-        )
-
-    async def run(self, *args: Any, **kwargs: Any) -> bool:
-        self._config = PortConfig(
-            host=self.render_str(self._host),
-            port=self.render_int(self._port),
-            timeout=self.render_int(self._timeout),
-        )
-        return await super().run(*args, **kwargs)
-
-    async def inspect(self, *args: Any, **kwargs: Any) -> bool:
-        try:
-            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
-                sock.settimeout(self._config.timeout)
-                result = sock.connect_ex((self._config.host, self._config.port))
-                if result == 0:
-                    self.print_out(f"{self._config.label} (OK)")
-                    return True
-                self.show_progress(f"{self._config.label} (Not OK)")
-        except Exception:
-            self.show_progress(f"{self._config.label} (Socker error)")
-        return False

zrb/task/recurring_task.py

@@ -1,203 +0,0 @@
-import asyncio
-import copy
-from collections.abc import Callable, Iterable, Mapping
-from typing import Any, Optional, Union
-
-from zrb.helper.accessories.color import colored
-from zrb.helper.accessories.name import get_random_name
-from zrb.helper.log import logger
-from zrb.helper.typecheck import typechecked
-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_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.recurring_task", attrs=["dark"]))
-
-
-class RunConfig:
-    def __init__(
-        self,
-        fn: Callable[..., Any],
-        args: list[Any],
-        kwargs: Mapping[Any, Any],
-        execution_id: str,
-    ):
-        self.fn = fn
-        self.args = args
-        self.kwargs = kwargs
-        self.execution_id = execution_id
-
-    async def run(self):
-        return await self.fn(*self.args, **self.kwargs)
-
-
-@typechecked
-class RecurringTask(BaseTask):
-    """
-    A class representing a recurring task that is triggered based on
-    specified conditions.
-
-    Examples:
-
-        >>> from zrb import RecurringTask
-    """
-
-    def __init__(
-        self,
-        name: str,
-        task: AnyTask,
-        triggers: Iterable[AnyTask] = [],
-        single_execution: bool = False,
-        group: Optional[Group] = None,
-        inputs: Iterable[AnyInput] = [],
-        envs: Iterable[Env] = [],
-        env_files: Iterable[EnvFile] = [],
-        icon: Optional[str] = None,
-        color: Optional[str] = None,
-        description: str = "",
-        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: float = 0.05,
-        retry: int = 0,
-        retry_interval: float = 1,
-        should_execute: Union[bool, str, Callable[..., bool]] = True,
-        return_upstream_result: bool = False,
-    ):
-        self._task: AnyTask = task.copy()
-        inputs = list(inputs) + self._task._get_combined_inputs()
-        envs = list(envs) + self._task._get_envs()
-        env_files = list(env_files) + self._task._get_env_files()
-        BaseTask.__init__(
-            self,
-            name=name,
-            group=group,
-            inputs=inputs,
-            envs=envs,
-            env_files=env_files,
-            icon=icon,
-            color=color,
-            description=description,
-            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,
-            should_execute=should_execute,
-            return_upstream_result=return_upstream_result,
-        )
-        self._triggers: list[AnyTask] = [trigger.copy() for trigger in triggers]
-        self._run_configs: list[RunConfig] = []
-        self._single_execution = single_execution
-        self.print_err("Deprecated, please use Server instead")
-
-    async def _set_keyval(self, kwargs: Mapping[str, Any], env_prefix: str):
-        await super()._set_keyval(kwargs=kwargs, env_prefix=env_prefix)
-        new_kwargs = copy.deepcopy(kwargs)
-        new_kwargs.update(self.get_input_map())
-        trigger_coroutines = []
-        for trigger in self._triggers:
-            trigger.add_input(*self._get_inputs())
-            trigger.add_env(*self._get_envs())
-            trigger_coroutines.append(
-                asyncio.create_task(
-                    trigger._set_keyval(kwargs=new_kwargs, env_prefix=env_prefix)
-                )
-            )
-        await asyncio.gather(*trigger_coroutines)
-
-    async def run(self, *args: Any, **kwargs: Any):
-        await asyncio.gather(
-            asyncio.create_task(self.__check_trigger(*args, **kwargs)),
-            asyncio.create_task(self.__run_from_queue()),
-        )
-
-    async def __check_trigger(self, *args: Any, **kwargs: Any):
-        task_kwargs = {key: kwargs[key] for key in kwargs if key not in ["_task"]}
-        is_first_time = True
-        while True:
-            execution_id = get_random_name(add_random_digit=True, digit_count=5)
-            # Create trigger functions
-            trigger_functions = []
-            for trigger in self._triggers:
-                trigger_copy = trigger.copy()
-                trigger_copy._set_execution_id(execution_id)
-                trigger_function = trigger_copy.to_function(
-                    is_async=True, raise_error=False, show_done_info=False
-                )
-                trigger_functions.append(
-                    asyncio.create_task(trigger_function(*args, **task_kwargs))
-                )
-            self.print_out_dark("Waiting for next trigger")
-            # Mark task as done since trigger has been defined.
-            if is_first_time:
-                await self._mark_done()
-                is_first_time = False
-            # Wait for the first task to complete
-            _, pending = await asyncio.wait(
-                trigger_functions, return_when=asyncio.FIRST_COMPLETED
-            )
-            # Cancel the remaining tasks
-            for process in pending:
-                try:
-                    process.cancel()
-                except Exception as e:
-                    self.print_err(e)
-            # Run the task
-            task_copy = self._task.copy()
-            task_copy._set_execution_id(execution_id)
-            fn = task_copy.to_function(
-                is_async=True, raise_error=False, show_done_info=False
-            )
-            self.print_out_dark(f"Add execution to the queue: {execution_id}")
-            self._run_configs.append(
-                RunConfig(
-                    fn=fn, args=args, kwargs=task_kwargs, execution_id=execution_id
-                )
-            )
-
-    async def __run_from_queue(self):
-        while True:
-            if len(self._run_configs) == 0:
-                await asyncio.sleep(0.05)
-                continue
-            if self._single_execution:
-                # Drain the queue, leave only the latest task
-                while len(self._run_configs) > 1:
-                    run_config = self._run_configs.pop(0)
-                    self.print_out_dark(f"Skipping {run_config.execution_id}")
-                    self.clear_xcom(execution_id=run_config.execution_id)
-            # Run task
-            run_config = self._run_configs.pop(0)
-            self.print_out_dark(f"Executing {run_config.execution_id}")
-            self.print_out_dark(f"{len(self._run_configs)} tasks left")
-            await run_config.run()
-            self.clear_xcom(execution_id=run_config.execution_id)
-            self._play_bell()

zrb/task/remote_cmd_task.py

@@ -1,156 +0,0 @@
-import os
-import pathlib
-from collections.abc import Callable, Iterable
-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,
-    OnReady,
-    OnRetry,
-    OnSkipped,
-    OnStarted,
-    OnTriggered,
-    OnWaiting,
-)
-from zrb.task.cmd_task import CmdTask, CmdVal
-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
-
-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")
-
-ensure_ssh_is_installed = CmdTask(
-    name="ensure-ssh-is-installed",
-    cmd_path=[
-        os.path.join(_SHELL_SCRIPT_DIR, "_common-util.sh"),
-        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(CmdTask):
-    def __init__(
-        self,
-        name: str,
-        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,
-        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,
-        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 + [PrivateEnv(name="_ZRB_SSH_PASSWORD", default=remote_password)],
-            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=[ensure_ssh_is_installed] + 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._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"'