zrb 0.9.2__py3-none-any.whl → 0.15.0__py3-none-any.whl

zrb/task/base_task/base_task.py

@@ -1,8 +1,10 @@
 import asyncio
 import copy
+import os
+import shutil
 
 from zrb.advertisement import advertisements
-from zrb.config.config import show_advertisement
+from zrb.config.config import show_advertisement, tmp_dir
 from zrb.helper.accessories.name import get_random_name
 from zrb.helper.advertisement import get_advertisement
 from zrb.helper.callable import run_async
@@ -25,7 +27,7 @@ from zrb.task.base_task.component.base_task_model import BaseTaskModel
 from zrb.task.base_task.component.renderer import Renderer
 from zrb.task.base_task.component.trackers import AttemptTracker, FinishTracker
 from zrb.task.parallel import AnyParallel
-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
@@ -38,7 +40,7 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
     Every task definition should be extended from this class.
     """
 
-    __xcom: Mapping[str, Mapping[str, str]] = {}
+    __running_tasks: List[AnyTask] = []
 
     def __init__(
         self,
@@ -53,6 +55,7 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
         retry: int = 2,
         retry_interval: Union[float, int] = 1,
         upstreams: Iterable[AnyTask] = [],
+        fallbacks: Iterable[AnyTask] = [],
         checkers: Iterable[AnyTask] = [],
         checking_interval: Union[float, int] = 0,
         run: Optional[Callable[..., Any]] = None,
@@ -87,6 +90,7 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
             retry=retry,
             retry_interval=retry_interval,
             upstreams=upstreams,
+            fallbacks=fallbacks,
             checkers=checkers,
             checking_interval=checking_interval,
             run=run,
@@ -119,29 +123,36 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
                 other_task.add_upstream(self)
             return operand
 
-    def set_task_xcom(self, key: str, value: Any) -> str:
+    def __get_xcom_dir(self, execution_id: Optional[str] = None) -> str:
+        if execution_id is None:
+            execution_id = self.get_execution_id()
+        return os.path.join(tmp_dir, f"xcom.{execution_id}")
+
+    def __ensure_xcom_dir_exists(self, execution_id: Optional[str] = None):
+        xcom_dir = self.__get_xcom_dir(execution_id=execution_id)
+        os.makedirs(xcom_dir, exist_ok=True)
+
+    def set_task_xcom(self, key: str, value: Any):
         return self.set_xcom(key=".".join([self.get_name(), key]), value=value)
 
-    def set_xcom(self, key: str, value: Any) -> str:
-        execution_id = self.get_execution_id()
-        if execution_id not in self.__xcom:
-            self.__xcom[execution_id] = {}
-        execution_id = self.get_execution_id()
-        self.__xcom[execution_id][key] = f"{value}"
-        return ""
+    def set_xcom(self, key: str, value: Any):
+        self.__ensure_xcom_dir_exists()
+        xcom_dir = self.__get_xcom_dir()
+        xcom_file = os.path.join(xcom_dir, key)
+        with open(xcom_file, "w") as f:
+            f.write(value)
 
     def get_xcom(self, key: str) -> str:
-        execution_id = self.get_execution_id()
-        if execution_id not in self.__xcom:
-            return ""
-        return self.__xcom[execution_id].get(key, "")
+        self.__ensure_xcom_dir_exists()
+        xcom_dir = self.__get_xcom_dir()
+        xcom_file = os.path.join(xcom_dir, key)
+        with open(xcom_file, "r") as f:
+            return f.read()
 
-    def clear_xcom(self, execution_id: str = "") -> str:
-        if execution_id == "":
-            execution_id = self.get_execution_id()
-        if execution_id in self.__xcom:
-            del self.__xcom[execution_id]
-            return ""
+    def clear_xcom(self, execution_id: str = ""):
+        xcom_dir = self.__get_xcom_dir(execution_id=execution_id)
+        if os.path.isdir(xcom_dir):
+            shutil.rmtree(xcom_dir)
 
     def copy(self) -> AnyTask:
         return copy.deepcopy(self)
@@ -152,17 +163,21 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
         raise_error: bool = True,
         is_async: bool = False,
         show_done_info: bool = True,
+        should_clear_xcom: bool = False,
     ) -> Callable[..., Any]:
         async def function(*args: Any, **kwargs: Any) -> Any:
             self.log_info("Copy task")
-            self_cp = self.copy()
-            return await self_cp._run_and_check_all(
+            self_cp: AnyTask = self.copy()
+            result = await self_cp._run_and_check_all(
                 env_prefix=env_prefix,
                 raise_error=raise_error,
                 args=args,
                 kwargs=kwargs,
                 show_done_info=show_done_info,
             )
+            if should_clear_xcom:
+                self_cp.clear_xcom()
+            return result
 
         if is_async:
             return function
@@ -216,6 +231,20 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
     async def check(self) -> bool:
         return await self._is_done()
 
+    def inject_envs(self):
+        super().inject_envs()
+        input_map = self.get_input_map()
+        for task_input in self._get_combined_inputs():
+            input_key = to_variable_name(task_input.get_name())
+            input_value = input_map.get(input_key)
+            env_name = "_INPUT_" + input_key.upper()
+            should_render = task_input.should_render()
+            self.add_env(
+                PrivateEnv(
+                    name=env_name, default=str(input_value), should_render=should_render
+                )
+            )
+
     async def _run_and_check_all(
         self,
         env_prefix: str,
@@ -257,7 +286,7 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
         except Exception as e:
             self.log_error(f"{e}")
             if raise_error:
-                raise
+                raise e
         finally:
             if show_done_info:
                 self._show_env_prefix()
@@ -303,7 +332,7 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
         self.log_debug("Waiting execution to be started")
         while not self.__is_execution_started:
             # Don't start checking before the execution itself has been started
-            await asyncio.sleep(0.1)
+            await asyncio.sleep(0.05)
         check_coroutines: Iterable[asyncio.Task] = []
         for checker_task in self._get_checkers():
             checker_task._set_execution_id(self.get_execution_id())
@@ -334,15 +363,7 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
         await self.on_triggered()
         self.__is_execution_triggered = True
         await self.on_waiting()
-        # get upstream checker
-        upstream_check_processes: Iterable[asyncio.Task] = []
-        self._lock_upstreams()
-        for upstream_task in self._get_upstreams():
-            upstream_check_processes.append(
-                asyncio.create_task(upstream_task._loop_check())
-            )
-        # wait all upstream checkers to complete
-        await asyncio.gather(*upstream_check_processes)
+        await self.__check_upstreams()
         # mark execution as started, so that checkers can start checking
         self.__is_execution_started = True
         local_kwargs = dict(kwargs)
@@ -353,27 +374,69 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
             return None
         # start running task
         result: Any = None
+        is_failed: bool = False
         while self._should_attempt():
             try:
                 self.log_debug(f"Started with args: {args} and kwargs: {local_kwargs}")
                 await self.on_started()
+                self.__running_tasks.append(self)
                 result = await run_async(self.run, *args, **local_kwargs)
+                self.__running_tasks.remove(self)
                 break
             except Exception as e:
-                is_last_attempt = self._is_last_attempt()
-                await self.on_failed(is_last_attempt, e)
-                if is_last_attempt:
-                    raise e
                 attempt = self._get_attempt()
                 self.log_error(f"Encounter error on attempt {attempt}")
+                if self._is_last_attempt():
+                    is_failed = True
+                    raise e
+                self.__running_tasks.remove(self)
+                await self.on_failed(is_last_attempt=False, exception=e)
                 self._increase_attempt()
                 await asyncio.sleep(self._retry_interval)
                 await self.on_retry()
+            finally:
+                if is_failed:
+                    running_tasks = self.__running_tasks
+                    self.__running_tasks = []
+                    await self.__trigger_failure(running_tasks)
+                    await self.__trigger_fallbacks(running_tasks, kwargs)
         self.set_xcom(self.get_name(), f"{result}")
-        self.log_debug(f"XCom: {self.__xcom}")
         await self._mark_done()
         return result
 
+    async def __check_upstreams(self):
+        coroutines: Iterable[asyncio.Task] = []
+        self._lock_upstreams()
+        for upstream_task in self._get_upstreams():
+            coroutines.append(asyncio.create_task(upstream_task._loop_check()))
+        # wait all upstream checkers to complete
+        await asyncio.gather(*coroutines)
+
+    async def __trigger_failure(self, tasks: List[AnyTask]):
+        coroutines = [
+            task.on_failed(is_last_attempt=True, exception=Exception("canceled"))
+            for task in tasks
+        ]
+        await asyncio.gather(*coroutines)
+
+    async def __trigger_fallbacks(
+        self, tasks: List[AnyTask], kwargs: Mapping[str, Any]
+    ):
+        coroutines: Iterable[asyncio.Task] = []
+        for fallback in self.__get_all_fallbacks(tasks):
+            fallback._set_execution_id(self.get_execution_id())
+            coroutines.append(asyncio.create_task(fallback._run_all(**kwargs)))
+        await asyncio.gather(*coroutines)
+
+    def __get_all_fallbacks(self, tasks: List[AnyTask]) -> List[AnyTask]:
+        all_fallbacks: List[AnyTask] = []
+        for task in tasks:
+            task._lock_fallbacks()
+            for fallback in task._get_fallbacks():
+                if fallback not in all_fallbacks:
+                    all_fallbacks.append(fallback)
+        return all_fallbacks
+
     async def _check_should_execute(self, *args: Any, **kwargs: Any) -> bool:
         if callable(self._should_execute):
             return await run_async(self._should_execute, *args, **kwargs)
@@ -438,7 +501,11 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
             if env.should_render():
                 env_value = self.render_any(env_value)
             self._set_env_map(env_name, env_value)
-        self._set_env_map("_ZRB_EXECUTION_ID", self.get_execution_id())
+        # Add some default Env Map
+        execution_id = self.get_execution_id()
+        self._set_env_map("_ZRB_EXECUTION_ID", execution_id)
+        xcom_dir = self.__get_xcom_dir()
+        self._set_env_map("_ZRB_XCOM_DIR", xcom_dir)
         self.log_debug("Env map:\n" + map_to_str(self.get_env_map(), item_prefix="  "))
 
     def __repr__(self) -> str:

zrb/task/base_task/component/base_task_model.py

@@ -56,6 +56,7 @@ class BaseTaskModel(CommonTaskModel, PidModel, TimeTracker):
         retry: int = 2,
         retry_interval: Union[int, float] = 1,
         upstreams: Iterable[AnyTask] = [],
+        fallbacks: Iterable[AnyTask] = [],
         checkers: Iterable[AnyTask] = [],
         checking_interval: Union[int, float] = 0,
         run: Optional[Callable[..., Any]] = None,
@@ -85,6 +86,7 @@ class BaseTaskModel(CommonTaskModel, PidModel, TimeTracker):
             retry=retry,
             retry_interval=retry_interval,
             upstreams=upstreams,
+            fallbacks=fallbacks,
             checkers=checkers,
             checking_interval=checking_interval,
             run=run,

zrb/task/base_task/component/common_task_model.py

@@ -47,6 +47,7 @@ class CommonTaskModel:
         retry: int = 2,
         retry_interval: Union[float, int] = 1,
         upstreams: Iterable[AnyTask] = [],
+        fallbacks: Iterable[AnyTask] = [],
         checkers: Iterable[AnyTask] = [],
         checking_interval: Union[float, int] = 0,
         run: Optional[Callable[..., Any]] = None,
@@ -73,6 +74,7 @@ class CommonTaskModel:
         self._retry = retry
         self._retry_interval = retry_interval
         self._upstreams = upstreams
+        self._fallbacks = fallbacks
         self._checkers = [checker.copy() for checker in checkers]
         self._checking_interval = checking_interval
         self._run_function: Optional[Callable[..., Any]] = run
@@ -90,16 +92,21 @@ class CommonTaskModel:
         self.__allow_add_env_files = True
         self.__allow_add_inputs = True
         self.__allow_add_upstreams: bool = True
+        self.__allow_add_fallbacks: bool = True
         self.__allow_add_checkers: bool = True
         self.__has_already_inject_env_files: bool = False
         self.__has_already_inject_envs: bool = False
         self.__has_already_inject_inputs: bool = False
         self.__has_already_inject_upstreams: bool = False
+        self.__has_already_inject_fallbacks: bool = False
         self.__all_inputs: Optional[List[AnyInput]] = None
 
     def _lock_upstreams(self):
         self.__allow_add_upstreams = False
 
+    def _lock_fallbacks(self):
+        self.__allow_add_fallbacks = False
+
     def _set_execution_id(self, execution_id: str):
         if self.__execution_id == "":
             self.__execution_id = execution_id
@@ -276,6 +283,25 @@ class CommonTaskModel:
             self.__has_already_inject_upstreams = True
         return list(self._upstreams)
 
+    def insert_fallback(self, *fallbacks: AnyTask):
+        if not self.__allow_add_fallbacks:
+            raise Exception(f"Cannot insert fallbacks to `{self.get_name()}`")
+        self._fallbacks = list(fallbacks) + list(self._fallbacks)
+
+    def add_fallback(self, *fallbacks: AnyTask):
+        if not self.__allow_add_fallbacks:
+            raise Exception(f"Cannot add fallbacks to `{self.get_name()}`")
+        self._fallbacks = list(self._fallbacks) + list(fallbacks)
+
+    def inject_fallbacks(self):
+        pass
+
+    def _get_fallbacks(self) -> List[AnyTask]:
+        if not self.__has_already_inject_fallbacks:
+            self.inject_fallbacks()
+            self.__has_already_inject_fallbacks = True
+        return list(self._fallbacks)
+
     def get_icon(self) -> str:
         return self._icon
 

zrb/task/checker.py

@@ -32,6 +32,7 @@ class Checker(BaseTask):
         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,
@@ -55,6 +56,7 @@ class Checker(BaseTask):
             color=color,
             description=description,
             upstreams=upstreams,
+            fallbacks=fallbacks,
             on_triggered=on_triggered,
             on_waiting=on_waiting,
             on_skipped=on_skipped,

zrb/task/cmd_task.py

@@ -113,6 +113,7 @@ class CmdTask(BaseTask):
         cmd_path: CmdVal = "",
         cwd: Optional[Union[str, pathlib.Path]] = None,
         upstreams: Iterable[AnyTask] = [],
+        fallbacks: Iterable[AnyTask] = [],
         on_triggered: Optional[OnTriggered] = None,
         on_waiting: Optional[OnWaiting] = None,
         on_skipped: Optional[OnSkipped] = None,
@@ -129,6 +130,9 @@ class CmdTask(BaseTask):
         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,
     ):
         BaseTask.__init__(
             self,
@@ -141,6 +145,7 @@ class CmdTask(BaseTask):
             color=color,
             description=description,
             upstreams=upstreams,
+            fallbacks=fallbacks,
             on_triggered=on_triggered,
             on_waiting=on_waiting,
             on_skipped=on_skipped,
@@ -169,6 +174,9 @@ class CmdTask(BaseTask):
         self._executable = executable
         self._process: Optional[asyncio.subprocess.Process]
         self._preexec_fn = preexec_fn
+        self._should_print_cmd_result = should_print_cmd_result
+        self._should_show_working_directory = should_show_working_directory
+        self._should_show_cmd = should_show_cmd
 
     def copy(self) -> TCmdTask:
         return super().copy()
@@ -192,31 +200,16 @@ class CmdTask(BaseTask):
         return super().to_function(env_prefix, raise_error, is_async, show_done_info)
 
     def print_result(self, result: CmdResult):
-        if result.output == "":
+        if not self._should_print_cmd_result or result.output == "":
             return
         print(result.output)
 
-    def inject_envs(self):
-        super().inject_envs()
-        input_map = self.get_input_map()
-        for task_input in self._get_combined_inputs():
-            input_key = to_variable_name(task_input.get_name())
-            input_value = input_map.get(input_key)
-            env_name = "_INPUT_" + input_key.upper()
-            should_render = task_input.should_render()
-            self.add_env(
-                Env(
-                    name=env_name,
-                    os_name="",
-                    default=str(input_value),
-                    should_render=should_render,
-                )
-            )
-
     async def run(self, *args: Any, **kwargs: Any) -> CmdResult:
         cmd = self.get_cmd_script(*args, **kwargs)
-        self.print_out_dark("Run script: " + self.__get_multiline_repr(cmd))
-        self.print_out_dark("Working directory: " + self._cwd)
+        if self._should_show_cmd:
+            self.print_out_dark("Run script: " + self.__get_multiline_repr(cmd))
+        if self._should_show_working_directory:
+            self.print_out_dark("Working directory: " + self._cwd)
         self._output_buffer = []
         self._error_buffer = []
         process = await asyncio.create_subprocess_shell(

zrb/task/docker_compose_task.py

@@ -1,6 +1,7 @@
 import os
 import pathlib
 
+from zrb.config.config import container_backend
 from zrb.helper.accessories.name import get_random_name
 from zrb.helper.docker_compose.fetch_external_env import fetch_compose_file_env_map
 from zrb.helper.docker_compose.file import read_compose_file, write_compose_file
@@ -36,27 +37,32 @@ from zrb.task_env.env_file import EnvFile
 from zrb.task_group.group import Group
 from zrb.task_input.any_input import AnyInput
 
-CURRENT_DIR = os.path.dirname(__file__)
-SHELL_SCRIPT_DIR = os.path.join(CURRENT_DIR, "..", "shell-scripts")
-TDockerComposeTask = TypeVar("TDockerComposeTask", bound="DockerComposeTask")
 
-ensure_docker_is_installed = CmdTask(
-    name="ensure-docker-is-installed",
-    cmd_path=[
-        os.path.join(SHELL_SCRIPT_DIR, "_common-util.sh"),
-        os.path.join(SHELL_SCRIPT_DIR, "ensure-docker-is-installed.sh"),
-    ],
-    preexec_fn=None,
-)
+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,
+    )
 
-ensure_zrb_network_exists = CmdTask(
-    name="ensure-zrb-network-exists",
-    cmd=[
-        "docker network inspect zrb >/dev/null 2>&1 || \\",
-        "docker network create -d bridge zrb",
-    ],
-    upstreams=[ensure_docker_is_installed],
-)
+
+TDockerComposeTask = TypeVar("TDockerComposeTask", bound="DockerComposeTask")
+ensure_zrb_network_task = _get_ensure_zrb_network_task(container_backend)
 
 
 @typechecked
@@ -96,6 +102,7 @@ class DockerComposeTask(CmdTask):
         setup_cmd_path: CmdVal = "",
         cwd: Optional[Union[str, pathlib.Path]] = None,
         upstreams: Iterable[AnyTask] = [],
+        fallbacks: Iterable[AnyTask] = [],
         on_triggered: Optional[OnTriggered] = None,
         on_waiting: Optional[OnWaiting] = None,
         on_skipped: Optional[OnSkipped] = None,
@@ -112,6 +119,9 @@ class DockerComposeTask(CmdTask):
         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,
     ):
         combined_env_files = list(env_files)
         CmdTask.__init__(
@@ -126,7 +136,8 @@ class DockerComposeTask(CmdTask):
             description=description,
             executable=executable,
             cwd=cwd,
-            upstreams=[ensure_zrb_network_exists] + upstreams,
+            upstreams=[ensure_zrb_network_task] + upstreams,
+            fallbacks=fallbacks,
             on_triggered=on_triggered,
             on_waiting=on_waiting,
             on_skipped=on_skipped,
@@ -143,6 +154,9 @@ class DockerComposeTask(CmdTask):
             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._setup_cmd = setup_cmd
         self._setup_cmd_path = setup_cmd_path
@@ -350,7 +364,7 @@ class DockerComposeTask(CmdTask):
         cmd_str = "\n".join(
             [
                 setup_cmd_str,
-                f"docker compose {options} {self._compose_cmd} {flags} {args}",
+                f"{container_backend} compose {options} {self._compose_cmd} {flags} {args}",  # noqa
             ]
         )
         self.log_info(f"Command: {cmd_str}")

zrb/task/flow_task.py

@@ -32,6 +32,7 @@ class FlowTask(BaseTask):
         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,
@@ -72,6 +73,7 @@ class FlowTask(BaseTask):
             color=color,
             description=description,
             upstreams=final_upstreams,
+            fallbacks=fallbacks,
             on_triggered=on_triggered,
             on_waiting=on_waiting,
             on_skipped=on_skipped,

zrb/task/http_checker.py

@@ -75,6 +75,7 @@ class HTTPChecker(Checker):
         url: str = "/",
         is_https: Union[bool, str] = False,
         upstreams: Iterable[AnyTask] = [],
+        fallbacks: Iterable[AnyTask] = [],
         on_triggered: Optional[OnTriggered] = None,
         on_waiting: Optional[OnWaiting] = None,
         on_skipped: Optional[OnSkipped] = None,
@@ -98,6 +99,7 @@ class HTTPChecker(Checker):
             color=color,
             description=description,
             upstreams=upstreams,
+            fallbacks=fallbacks,
             on_triggered=on_triggered,
             on_waiting=on_waiting,
             on_skipped=on_skipped,

zrb/task/notifier.py

@@ -21,10 +21,10 @@ from zrb.task_env.env_file import EnvFile
 from zrb.task_group.group import Group
 from zrb.task_input.any_input import AnyInput
 
-CURRENT_DIR = os.path.dirname(__file__)
-NOTIFY_PS1_PATH = os.path.realpath(
+_CURRENT_DIR = os.path.dirname(__file__)
+_NOTIFY_PS1_PATH = os.path.realpath(
     os.path.abspath(
-        os.path.join(os.path.dirname(CURRENT_DIR), "shell-scripts", "notify.ps1")
+        os.path.join(os.path.dirname(_CURRENT_DIR), "shell-scripts", "notify.ps1")
     )
 )
 
@@ -46,6 +46,7 @@ class Notifier(BaseTask):
         show_toast: bool = True,
         show_stdout: bool = True,
         upstreams: Iterable[AnyTask] = [],
+        fallbacks: Iterable[AnyTask] = [],
         on_triggered: Optional[OnTriggered] = None,
         on_waiting: Optional[OnWaiting] = None,
         on_skipped: Optional[OnSkipped] = None,
@@ -69,6 +70,7 @@ class Notifier(BaseTask):
             color=color,
             description=description,
             upstreams=upstreams,
+            fallbacks=fallbacks,
             on_triggered=on_triggered,
             on_waiting=on_waiting,
             on_skipped=on_skipped,
@@ -106,7 +108,7 @@ class Notifier(BaseTask):
                 "-ExecutionPolicy",
                 "Bypass",
                 "-File",
-                NOTIFY_PS1_PATH,
+                _NOTIFY_PS1_PATH,
                 "-Title",
                 title,
                 "-Message",

zrb/task/path_checker.py

@@ -42,6 +42,7 @@ class PathChecker(Checker):
         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,
@@ -67,6 +68,7 @@ class PathChecker(Checker):
             color=color,
             description=description,
             upstreams=upstreams,
+            fallbacks=fallbacks,
             on_triggered=on_triggered,
             on_waiting=on_waiting,
             on_skipped=on_skipped,

zrb/task/path_watcher.py

@@ -56,6 +56,7 @@ class PathWatcher(Checker):
         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,
@@ -83,6 +84,7 @@ class PathWatcher(Checker):
             color=color,
             description=description,
             upstreams=upstreams,
+            fallbacks=fallbacks,
             on_triggered=on_triggered,
             on_waiting=on_waiting,
             on_skipped=on_skipped,

zrb/task/port_checker.py

@@ -54,6 +54,7 @@ class PortChecker(Checker):
         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,
@@ -77,6 +78,7 @@ class PortChecker(Checker):
             color=color,
             description=description,
             upstreams=upstreams,
+            fallbacks=fallbacks,
             on_triggered=on_triggered,
             on_waiting=on_waiting,
             on_skipped=on_skipped,

zrb/task/recurring_task.py

@@ -63,6 +63,7 @@ class RecurringTask(BaseTask):
         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,
@@ -92,6 +93,7 @@ class RecurringTask(BaseTask):
             color=color,
             description=description,
             upstreams=upstreams,
+            fallbacks=fallbacks,
             on_triggered=on_triggered,
             on_waiting=on_waiting,
             on_skipped=on_skipped,