zrb 0.17.2__py3-none-any.whl → 0.21.0__py3-none-any.whl

zrb/task/base_task/component/common_task_model.py

@@ -49,7 +49,7 @@ class CommonTaskModel:
         upstreams: Iterable[AnyTask] = [],
         fallbacks: Iterable[AnyTask] = [],
         checkers: Iterable[AnyTask] = [],
-        checking_interval: Union[float, int] = 0,
+        checking_interval: Union[float, int] = 0.05,
         run: Optional[Callable[..., Any]] = None,
         on_triggered: Optional[OnTriggered] = None,
         on_waiting: Optional[OnWaiting] = None,
@@ -65,6 +65,11 @@ class CommonTaskModel:
         self._group = group
         if group is not None:
             group._add_task(self)
+        checkers_cp: List[AnyTask] = [checker.copy() for checker in checkers]
+        for checker in checkers_cp:
+            checker.add_env(*envs)
+            checker.add_env_file(*env_files)
+            checker.add_input(*inputs)
         self._description = coalesce_str(description, name)
         self._inputs = inputs
         self._envs = envs
@@ -75,7 +80,7 @@ class CommonTaskModel:
         self._retry_interval = retry_interval
         self._upstreams = upstreams
         self._fallbacks = fallbacks
-        self._checkers = [checker.copy() for checker in checkers]
+        self._checkers = checkers_cp
         self._checking_interval = checking_interval
         self._run_function: Optional[Callable[..., Any]] = run
         self._on_triggered = on_triggered
@@ -101,6 +106,9 @@ class CommonTaskModel:
         self.__has_already_inject_fallbacks: bool = False
         self.__all_inputs: Optional[List[AnyInput]] = None
 
+    def _lock_checkers(self):
+        self.__allow_add_checkers = False
+
     def _lock_upstreams(self):
         self.__allow_add_upstreams = False
 
@@ -164,11 +172,15 @@ class CommonTaskModel:
         if not self.__allow_add_inputs:
             raise Exception(f"Cannot insert inputs for `{self.get_name()}`")
         self._inputs = list(inputs) + list(self._inputs)
+        for checker in self._get_checkers():
+            checker.insert_input(*inputs)
 
     def add_input(self, *inputs: AnyInput):
         if not self.__allow_add_inputs:
             raise Exception(f"Cannot add inputs for `{self.get_name()}`")
         self._inputs = list(self._inputs) + list(inputs)
+        for checker in self._get_checkers():
+            checker.add_input(*inputs)
 
     def inject_inputs(self):
         pass
@@ -219,11 +231,15 @@ class CommonTaskModel:
         if not self.__allow_add_envs:
             raise Exception(f"Cannot insert envs to `{self.get_name()}`")
         self._envs = list(envs) + list(self._envs)
+        for checker in self._get_checkers():
+            checker.insert_env(*envs)
 
     def add_env(self, *envs: Env):
         if not self.__allow_add_envs:
             raise Exception(f"Cannot add envs to `{self.get_name()}`")
         self._envs = list(self._envs) + list(envs)
+        for checker in self._get_checkers():
+            checker.add_env(*envs)
 
     def inject_envs(self):
         pass
@@ -255,11 +271,15 @@ class CommonTaskModel:
         if not self.__allow_add_env_files:
             raise Exception(f"Cannot insert env_files to `{self.get_name()}`")
         self._env_files = list(env_files) + list(self._env_files)
+        for checker in self._get_checkers():
+            checker.insert_env_file(*env_files)
 
     def add_env_file(self, *env_files: EnvFile):
         if not self.__allow_add_env_files:
             raise Exception(f"Cannot add env_files to `{self.get_name()}`")
         self._env_files = list(self._env_files) + list(env_files)
+        for checker in self._get_checkers():
+            checker.add_env_file(*env_files)
 
     def inject_env_files(self):
         pass
@@ -317,15 +337,26 @@ class CommonTaskModel:
     def insert_checker(self, *checkers: AnyTask):
         if not self.__allow_add_checkers:
             raise Exception(f"Cannot insert checkers to `{self.get_name()}`")
-        additional_checkers = [checker.copy() for checker in checkers]
+        additional_checkers = self.__complete_new_checkers(checkers)
         self._checkers = additional_checkers + self._checkers
 
     def add_checker(self, *checkers: AnyTask):
         if not self.__allow_add_checkers:
             raise Exception(f"Cannot add checkers to `{self.get_name()}`")
-        additional_checkers = [checker.copy() for checker in checkers]
+        additional_checkers = self.__complete_new_checkers(checkers)
         self._checkers = self._checkers + additional_checkers
 
+    def __complete_new_checkers(self, new_checkers: List[AnyTask]) -> List[AnyTask]:
+        """
+        For internal use: copy and completing new checkers
+        """
+        checkers: List[AnyTask] = [checker.copy() for checker in new_checkers]
+        for checker in checkers:
+            checker.add_input(*self._get_inputs())
+            checker.add_env(*self._get_envs())
+            checker.add_env_file(*self._get_env_files())
+        return checkers
+
     def inject_checkers(self):
         pass
 

zrb/task/checker.py

@@ -44,7 +44,7 @@ class Checker(BaseTask):
         on_ready: Optional[OnReady] = None,
         on_retry: Optional[OnRetry] = None,
         on_failed: Optional[OnFailed] = None,
-        checking_interval: Union[int, float] = 0,
+        checking_interval: Union[int, float] = 0.05,
         progress_interval: Union[int, float] = 30,
         expected_result: bool = True,
         should_execute: Union[bool, str, Callable[..., bool]] = True,

zrb/task/cmd_task.py

@@ -1,5 +1,6 @@
 import asyncio
 import atexit
+import logging
 import os
 import pathlib
 import signal
@@ -7,7 +8,7 @@ import subprocess
 import sys
 import time
 
-from zrb.config.config import default_shell
+from zrb.config.config import default_shell, logging_level
 from zrb.helper.accessories.color import colored
 from zrb.helper.log import logger
 from zrb.helper.typecheck import typechecked
@@ -55,6 +56,18 @@ def _reset_stty():
             _has_stty = False
 
 
+def _log_error(message: Any):
+    if logging_level > logging.ERROR:
+        return
+    colored_message = colored(f"{message}", color="red", attrs=["bold"])
+    logger.error(colored_message, exc_info=True)
+
+
+def _print_out_dark(message: Any):
+    message_str = f"{message}"
+    print(colored(message_str, attrs=["dark"]), file=sys.stderr)
+
+
 CmdVal = Union[
     JinjaTemplate,
     Iterable[JinjaTemplate],
@@ -125,7 +138,7 @@ class CmdTask(BaseTask):
         on_retry: Optional[OnRetry] = None,
         on_failed: Optional[OnFailed] = None,
         checkers: Iterable[AnyTask] = [],
-        checking_interval: Union[float, int] = 0,
+        checking_interval: Union[float, int] = 0.05,
         retry: int = 2,
         retry_interval: Union[float, int] = 1,
         max_output_line: int = 1000,
@@ -272,7 +285,7 @@ class CmdTask(BaseTask):
     def __on_kill(self, signum: Any, frame: Any):
         self._global_state.no_more_attempt = True
         self._global_state.is_killed_by_signal = True
-        self.print_out_dark(f"Getting signal {signum}")
+        _print_out_dark(f"Getting signal {signum}")
         for pid in self._pids:
             self.__kill_by_pid(pid)
         tasks = asyncio.all_tasks()
@@ -282,7 +295,7 @@ class CmdTask(BaseTask):
             except Exception as e:
                 self.print_err(e)
         time.sleep(0.3)
-        self.print_out_dark(f"Exiting with signal {signum}")
+        _print_out_dark(f"Exiting with signal {signum}")
         sys.exit(signum)
 
     def __on_exit(self):
@@ -297,20 +310,20 @@ class CmdTask(BaseTask):
             process_ever_exists = False
             if self.__is_process_exist(pid):
                 process_ever_exists = True
-                self.print_out_dark(f"Send SIGTERM to process {pid}")
+                _print_out_dark(f"Send SIGTERM to process {pid}")
                 os.killpg(os.getpgid(pid), signal.SIGTERM)
                 time.sleep(0.3)
             if self.__is_process_exist(pid):
-                self.print_out_dark(f"Send SIGINT to process {pid}")
+                _print_out_dark(f"Send SIGINT to process {pid}")
                 os.killpg(os.getpgid(pid), signal.SIGINT)
                 time.sleep(0.3)
             if self.__is_process_exist(pid):
-                self.print_out_dark(f"Send SIGKILL to process {pid}")
+                _print_out_dark(f"Send SIGKILL to process {pid}")
                 os.killpg(os.getpgid(pid), signal.SIGKILL)
             if process_ever_exists:
-                self.print_out_dark(f"Process {pid} is killed successfully")
+                _print_out_dark(f"Process {pid} is killed successfully")
         except Exception:
-            self.log_error(f"Cannot kill process {pid}")
+            _log_error(f"Cannot kill process {pid}")
 
     def __is_process_exist(self, pid: int) -> bool:
         try:

zrb/task/decorator.py

@@ -43,7 +43,7 @@ def python_task(
     on_retry: Optional[OnRetry] = None,
     on_failed: Optional[OnFailed] = None,
     checkers: Iterable[AnyTask] = [],
-    checking_interval: Union[float, int] = 0,
+    checking_interval: Union[float, int] = 0.05,
     retry: int = 2,
     retry_interval: Union[float, int] = 1,
     should_execute: Union[bool, str, Callable[..., bool]] = True,

zrb/task/docker_compose_task.py

@@ -115,7 +115,7 @@ class DockerComposeTask(CmdTask):
         on_retry: Optional[OnRetry] = None,
         on_failed: Optional[OnFailed] = None,
         checkers: Iterable[AnyTask] = [],
-        checking_interval: Union[float, int] = 0,
+        checking_interval: Union[float, int] = 0.05,
         retry: int = 2,
         retry_interval: Union[float, int] = 1,
         max_output_line: int = 1000,

zrb/task/flow_task.py

@@ -45,27 +45,13 @@ class FlowTask(BaseTask):
         on_retry: Optional[OnRetry] = None,
         on_failed: Optional[OnFailed] = None,
         checkers: Iterable[AnyTask] = [],
-        checking_interval: float = 0,
+        checking_interval: Union[float, int] = 0.05,
         retry: int = 2,
-        retry_interval: float = 1,
+        retry_interval: Union[float, int] = 1,
         steps: List[Union[AnyTask, List[AnyTask]]] = [],
         should_execute: Union[bool, str, Callable[..., bool]] = True,
         return_upstream_result: bool = False,
     ):
-        final_upstreams: List[AnyTask] = list(upstreams)
-        inputs: List[AnyInput] = list(inputs)
-        envs: List[Env] = list(envs)
-        env_files: List[EnvFile] = list(env_files)
-        for step in steps:
-            tasks = self._step_to_tasks(step)
-            new_upstreams = self._get_embeded_tasks(
-                tasks=tasks,
-                upstreams=final_upstreams,
-                inputs=inputs,
-                envs=envs,
-                env_files=env_files,
-            )
-            final_upstreams = new_upstreams
         BaseTask.__init__(
             self,
             name=name,
@@ -76,7 +62,13 @@ class FlowTask(BaseTask):
             icon=icon,
             color=color,
             description=description,
-            upstreams=final_upstreams,
+            upstreams=self._create_flow_upstreams(
+                steps=steps,
+                upstreams=list(upstreams),
+                inputs=list(inputs),
+                envs=list(envs),
+                env_files=list(env_files),
+            ),
             fallbacks=fallbacks,
             on_triggered=on_triggered,
             on_waiting=on_waiting,
@@ -97,12 +89,33 @@ class FlowTask(BaseTask):
     def copy(self) -> TFlowTask:
         return super().copy()
 
-    def _step_to_tasks(self, node: Union[AnyTask, List[AnyTask]]) -> List[AnyTask]:
-        if isinstance(node, AnyTask):
-            return [node]
-        return node
+    def _create_flow_upstreams(
+        self,
+        steps: List[Union[AnyTask, List[AnyTask]]],
+        upstreams: List[AnyTask],
+        inputs: List[AnyInput],
+        envs: List[Env],
+        env_files: List[EnvFile],
+    ) -> List[AnyTask]:
+        flow_upstreams = upstreams
+        for step in steps:
+            tasks = [task.copy() for task in self._step_to_tasks(step)]
+            new_upstreams = self._create_embeded_tasks(
+                tasks=tasks,
+                upstreams=flow_upstreams,
+                inputs=inputs,
+                envs=envs,
+                env_files=env_files,
+            )
+            flow_upstreams = new_upstreams
+        return flow_upstreams
+
+    def _step_to_tasks(self, step: Union[AnyTask, List[AnyTask]]) -> List[AnyTask]:
+        if isinstance(step, AnyTask):
+            return [step]
+        return step
 
-    def _get_embeded_tasks(
+    def _create_embeded_tasks(
         self,
         tasks: List[AnyTask],
         upstreams: List[AnyTask],
@@ -111,28 +124,26 @@ class FlowTask(BaseTask):
         env_files: List[EnvFile],
     ) -> List[AnyTask]:
         embeded_tasks: List[AnyTask] = []
-        for task in tasks:
-            embeded_task = task.copy()
-            embeded_task_root_upstreams = self._get_root_upstreams(tasks=[embeded_task])
-            for embeded_task_root_upstream in embeded_task_root_upstreams:
-                embeded_task_root_upstream.add_upstream(*upstreams)
-            # embeded_task.add_upstream(*upstreams)
+        for embeded_task in tasks:
+            embeded_task_upstreams = self._get_all_upstreams(tasks=[embeded_task])
+            for embeded_task_upstream in embeded_task_upstreams:
+                embeded_task_upstream.add_upstream(*upstreams)
             embeded_task.add_env(*envs)
             embeded_task.add_env_file(*env_files)
             embeded_task.add_input(*inputs)
             embeded_tasks.append(embeded_task)
         return embeded_tasks
 
-    def _get_root_upstreams(self, tasks: List[AnyTask]):
-        root_upstreams = []
+    def _get_all_upstreams(self, tasks: List[AnyTask]):
+        all_upstreams = []
         for task in tasks:
             upstreams = task._get_upstreams()
             if len(upstreams) == 0:
-                root_upstreams.append(task)
+                all_upstreams.append(task)
                 continue
             for upstream in upstreams:
                 if len(upstream._get_upstreams()) == 0:
-                    root_upstreams.append(upstream)
+                    all_upstreams.append(upstream)
                     continue
-                root_upstreams += self._get_root_upstreams([upstream])
-        return root_upstreams
+                all_upstreams += self._get_all_upstreams([upstream])
+        return all_upstreams

zrb/task/http_checker.py

@@ -87,7 +87,7 @@ class HTTPChecker(Checker):
         on_ready: Optional[OnReady] = None,
         on_retry: Optional[OnRetry] = None,
         on_failed: Optional[OnFailed] = None,
-        checking_interval: Union[int, float] = 0,
+        checking_interval: Union[int, float] = 0.05,
         progress_interval: Union[int, float] = 5,
         expected_result: bool = True,
         should_execute: Union[bool, JinjaTemplate, Callable[..., bool]] = True,

zrb/task/notifier.py

@@ -58,7 +58,7 @@ class Notifier(BaseTask):
         on_ready: Optional[OnReady] = None,
         on_retry: Optional[OnRetry] = None,
         on_failed: Optional[OnFailed] = None,
-        checking_interval: Union[int, float] = 0,
+        checking_interval: Union[int, float] = 0.05,
         retry: int = 2,
         retry_interval: Union[float, int] = 1,
         should_execute: Union[bool, str, Callable[..., bool]] = True,

zrb/task/path_checker.py

@@ -56,7 +56,7 @@ class PathChecker(Checker):
         on_failed: Optional[OnFailed] = None,
         path: JinjaTemplate = "",
         ignored_path: Union[JinjaTemplate, Iterable[JinjaTemplate]] = [],
-        checking_interval: Union[int, float] = 0,
+        checking_interval: Union[int, float] = 0.05,
         progress_interval: Union[int, float] = 5,
         expected_result: bool = True,
         should_execute: Union[bool, JinjaTemplate, Callable[..., bool]] = True,

zrb/task/path_watcher.py

@@ -72,7 +72,7 @@ class PathWatcher(Watcher):
         on_failed: Optional[OnFailed] = None,
         path: JinjaTemplate = "",
         ignored_path: Union[JinjaTemplate, Iterable[JinjaTemplate]] = [],
-        checking_interval: Union[int, float] = 0,
+        checking_interval: Union[int, float] = 0.05,
         progress_interval: Union[int, float] = 30,
         watch_new_files: bool = True,
         watch_modified_files: bool = True,

zrb/task/port_checker.py

@@ -66,7 +66,7 @@ class PortChecker(Checker):
         on_ready: Optional[OnReady] = None,
         on_retry: Optional[OnRetry] = None,
         on_failed: Optional[OnFailed] = None,
-        checking_interval: Union[int, float] = 0,
+        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,

zrb/task/recurring_task.py

@@ -76,7 +76,7 @@ class RecurringTask(BaseTask):
         on_retry: Optional[OnRetry] = None,
         on_failed: Optional[OnFailed] = None,
         checkers: Iterable[AnyTask] = [],
-        checking_interval: float = 0,
+        checking_interval: float = 0.05,
         retry: int = 0,
         retry_interval: float = 1,
         should_execute: Union[bool, str, Callable[..., bool]] = True,
@@ -185,7 +185,7 @@ class RecurringTask(BaseTask):
     async def __run_from_queue(self):
         while True:
             if len(self._run_configs) == 0:
-                await asyncio.sleep(0.1)
+                await asyncio.sleep(0.05)
                 continue
             if self._single_execution:
                 # Drain the queue, leave only the latest task

zrb/task/remote_cmd_task.py

@@ -66,7 +66,7 @@ class RemoteCmdTask(BaseRemoteCmdTask):
         on_retry: Optional[OnRetry] = None,
         on_failed: Optional[OnFailed] = None,
         checkers: Iterable[AnyTask] = [],
-        checking_interval: Union[float, int] = 0,
+        checking_interval: Union[float, int] = 0.05,
         retry: int = 2,
         retry_interval: Union[float, int] = 1,
         max_output_line: int = 1000,

zrb/task/resource_maker.py

@@ -123,7 +123,7 @@ class ResourceMaker(BaseTask):
             on_retry=on_retry,
             on_failed=on_failed,
             checkers=[],
-            checking_interval=0.1,
+            checking_interval=0.05,
             retry=0,
             retry_interval=0,
             should_execute=should_execute,

zrb/task/rsync_task.py

@@ -48,8 +48,8 @@ class RsyncTask(BaseRemoteCmdTask):
         remote_configs: Iterable[RemoteConfig],
         src: JinjaTemplate,
         dst: JinjaTemplate,
-        is_remote_src: bool = False,
-        is_remote_dst: bool = True,
+        src_is_remote: bool = False,
+        dst_is_remote: bool = True,
         group: Optional[Group] = None,
         inputs: Iterable[AnyInput] = [],
         envs: Iterable[Env] = [],
@@ -69,7 +69,7 @@ class RsyncTask(BaseRemoteCmdTask):
         on_retry: Optional[OnRetry] = None,
         on_failed: Optional[OnFailed] = None,
         checkers: Iterable[AnyTask] = [],
-        checking_interval: Union[float, int] = 0,
+        checking_interval: Union[float, int] = 0.05,
         retry: int = 2,
         retry_interval: Union[float, int] = 1,
         max_output_line: int = 1000,
@@ -77,8 +77,8 @@ class RsyncTask(BaseRemoteCmdTask):
         preexec_fn: Optional[Callable[[], Any]] = os.setsid,
         should_execute: Union[bool, str, Callable[..., bool]] = True,
     ):
-        parsed_src = self._get_parsed_path(is_remote_src, src)
-        parsed_dst = self._get_parsed_path(is_remote_dst, dst)
+        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__(
             self,

zrb/task/server.py

@@ -1,4 +1,5 @@
 import asyncio
+import copy
 
 from zrb.helper.accessories.color import colored
 from zrb.helper.accessories.name import get_random_name
@@ -35,8 +36,8 @@ class Controller:
         name: Optional[str] = None,
     ):
         self._name = get_random_name() if name is None else name
-        self._triggers = [trigger] if isinstance(trigger, AnyTask) else trigger
-        self._actions = [action] if isinstance(action, AnyTask) else action
+        self._triggers = self._to_task_list(trigger)
+        self._actions = self._to_task_list(action)
         self._args: List[Any] = []
         self._kwargs: Mapping[str, Any] = {}
         self._inputs: List[AnyInput] = []
@@ -58,28 +59,28 @@ class Controller:
     def set_env_files(self, env_files: List[EnvFile]):
         self._env_files = env_files
 
-    def get_sub_env_files(self) -> Iterable[EnvFile]:
+    def get_original_env_files(self) -> Iterable[EnvFile]:
         env_files = []
         for trigger in self._triggers:
-            env_files += trigger.copy()._get_env_files()
+            env_files += trigger._get_env_files()
         for action in self._actions:
-            env_files += action.copy()._get_env_files()
+            env_files += action._get_env_files()
         return env_files
 
-    def get_sub_envs(self) -> Iterable[Env]:
+    def get_original_envs(self) -> Iterable[Env]:
         envs = []
         for trigger in self._triggers:
-            envs += trigger.copy()._get_envs()
+            envs += trigger._get_envs()
         for action in self._actions:
-            envs += action.copy()._get_envs()
+            envs += action._get_envs()
         return envs
 
-    def get_sub_inputs(self) -> Iterable[AnyInput]:
+    def get_original_inputs(self) -> Iterable[AnyInput]:
         inputs = []
         for trigger in self._triggers:
-            inputs += trigger.copy()._get_combined_inputs()
+            inputs += trigger._get_combined_inputs()
         for action in self._actions:
-            inputs += action.copy()._get_combined_inputs()
+            inputs += action._get_combined_inputs()
         return inputs
 
     def to_function(self) -> Callable[..., Any]:
@@ -92,6 +93,11 @@ class Controller:
 
         return fn
 
+    def _to_task_list(self, tasks: Union[AnyTask, List[AnyTask]]) -> List[AnyTask]:
+        if isinstance(tasks, AnyTask):
+            return [tasks.copy()]
+        return [task.copy() for task in tasks]
+
     def _get_task(self) -> AnyTask:
         actions = [action.copy() for action in self._actions]
         actions.insert(0, self._get_remonitor_task())
@@ -123,7 +129,7 @@ class Server(BaseTask):
     def __init__(
         self,
         name: str,
-        controllers: List[Controller],
+        controllers: Iterable[Controller],
         group: Optional[Group] = None,
         inputs: Iterable[AnyInput] = [],
         envs: Iterable[Env] = [],
@@ -141,17 +147,18 @@ class Server(BaseTask):
         on_retry: Optional[OnRetry] = None,
         on_failed: Optional[OnFailed] = None,
         checkers: Iterable[AnyTask] = [],
-        checking_interval: float = 0,
+        checking_interval: Union[int, float] = 0.05,
         retry: int = 0,
-        retry_interval: float = 1,
+        retry_interval: Union[int, float] = 1,
         should_execute: Union[bool, str, Callable[..., bool]] = True,
         return_upstream_result: bool = False,
     ):
         inputs, envs, env_files = list(inputs), list(envs), list(env_files)
         for controller in controllers:
-            inputs += controller.get_sub_inputs()
-            envs += controller.get_sub_envs()
-            env_files += controller.get_sub_env_files()
+            controller_cp = copy.deepcopy(controller)
+            inputs += controller_cp.get_original_inputs()
+            envs += controller_cp.get_original_envs()
+            env_files += controller_cp.get_original_env_files()
         BaseTask.__init__(
             self,
             name=name,
@@ -178,7 +185,7 @@ class Server(BaseTask):
             should_execute=should_execute,
             return_upstream_result=return_upstream_result,
         )
-        self._controllers = controllers
+        self._controllers = list(controllers)
 
     async def run(self, *args: Any, **kwargs: Any):
         for controller in self._controllers:

zrb/task/task.py

@@ -9,7 +9,41 @@ logger.debug(colored("Loading zrb.task.task", attrs=["dark"]))
 @typechecked
 class Task(BaseTask):
     """
-    Alias for BaseTask.
+    Task is the smallest Zrb automation unit.
+
+    You can configure a Task by using several interfaces:
+    - `inputs`: interfaces to read user input at the beginning of the execution.
+    - `envs`: interfaces to read and use OS Environment Variables.
+    - `env_files`: interfaces to read and use Environment Files.
+
+    Moreover, you can define Task dependencies by specifying its `upstreams` or by using shift-right operator.
+
+    Every Zrb Task has its life-cycle state:
+    - `Triggered`: The Task is triggered (either by the user or by the other Task).
+    - `Waiting`: Zrb has already triggered the Task. The Task is now waiting for all its upstreams to be ready.
+    - `Skipped`: Task upstreams are ready, but the Task is not executed and will immediately enter the `Ready` state.
+    - `Started`: The upstreams are ready, and Zrb is now starting the Task execution.
+    - `Failed`: Zrb failed to execute the Task. It will enter the `Retry` state if the current attempt does not exceed the maximum attempt.
+    - `Retry`: The task has already entered the `Failed` state. Now, Zrb will try to start the Task execution.
+    - `Ready`: The task is ready.
+
+    There are several configurations related to Task's life cycle:
+    - `retry`: Maximum retry attempt.
+    - `retry_interval`: The duration is to wait before Zrb starts the next attempt.
+    - `fallbacks`: Action to take if the Task has failed for good.
+    - `checkers`: How to determine if a Task is `Ready`.
+    - `checking_interval`: The duration to wait before Zrb checks for the Task's readiness.
+    - `run`: Action to do when Zrb executes the Task.
+    - `on_triggered`: Action to do when a Task is `Triggered`.
+    - `on_waiting`: Action to do when a Task is `Waiting`.
+    - `on_skipped`: Action to do when a Task is `Skipped`.
+    - `on_started`: Action to do when a Task is `Started`.
+    - `on_ready`: Action to do when a Task is `Ready`.
+    - `on_retry`: Action to do when a Task is `Retry`.
+    - `on_failed`: Action to do when a Task is `Failed`.
+    - `should_execute`: Condition to determine whether a Task should be `Started` or `Skipped`.
+
+    Finally, you can put related Tasks under the same `group`.
     """
 
     pass

zrb/task/time_watcher.py

@@ -68,7 +68,7 @@ class TimeWatcher(Watcher):
         on_retry: Optional[OnRetry] = None,
         on_failed: Optional[OnFailed] = None,
         schedule: JinjaTemplate = "",
-        checking_interval: Union[int, float] = 0,
+        checking_interval: Union[int, float] = 0.05,
         progress_interval: Union[int, float] = 30,
         should_execute: Union[bool, JinjaTemplate, Callable[..., bool]] = True,
     ):

zrb/task/watcher.py

@@ -2,6 +2,7 @@ import asyncio
 
 from zrb.helper.accessories.color import colored
 from zrb.helper.accessories.name import get_random_name
+from zrb.helper.callable import run_async
 from zrb.helper.log import logger
 from zrb.helper.typecheck import typechecked
 from zrb.helper.typing import Any, Callable, Iterable, Optional, Union
@@ -48,7 +49,7 @@ class Watcher(Checker):
         on_ready: Optional[OnReady] = None,
         on_retry: Optional[OnRetry] = None,
         on_failed: Optional[OnFailed] = None,
-        checking_interval: Union[int, float] = 0,
+        checking_interval: Union[int, float] = 0.05,
         progress_interval: Union[int, float] = 30,
         expected_result: bool = True,
         should_execute: Union[bool, str, Callable[..., bool]] = True,
@@ -85,7 +86,9 @@ class Watcher(Checker):
     async def run(self, *args: Any, **kwargs: Any) -> bool:
         if not looper.is_registered(self._identifier):
             asyncio.create_task(
-                looper.register(self._identifier, self.create_loop_inspector())
+                run_async(
+                    looper.register, self._identifier, self.create_loop_inspector()
+                )
             )
         return await super().run(*args, **kwargs)