zrb 0.1.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

zrb/task/base_task/component/base_task_model.py

@@ -2,7 +2,7 @@ from zrb.helper.typing import (
     Any, Callable, Iterable, List, Mapping, Optional, Union
 )
 from zrb.helper.typecheck import typechecked
-from zrb.config.config import show_time
+from zrb.config.config import show_time, logging_level
 from zrb.task.any_task import AnyTask
 from zrb.task.any_task_event_handler import (
     OnTriggered, OnWaiting, OnSkipped, OnStarted, OnReady, OnRetry, OnFailed
@@ -19,8 +19,10 @@ from zrb.task.base_task.component.trackers import TimeTracker
 from zrb.config.config import env_prefix
 from zrb.helper.string.modification import double_quote
 from zrb.helper.string.conversion import to_variable_name
+from functools import lru_cache
 
 import datetime
+import logging
 import os
 import sys
 
@@ -90,12 +92,20 @@ class BaseTaskModel(CommonTaskModel, PidModel, TimeTracker):
         self.__kwargs: Mapping[str, Any] = {}
 
     def _set_args(self, args: Iterable[Any]):
+        '''
+        Set args that will be shown at the end of the execution
+        '''
         self.__args = list(args)
 
     def _set_kwargs(self, kwargs: Mapping[str, Any]):
+        '''
+        Set kwargs that will be shown at the end of the execution
+        '''
         self.__kwargs = kwargs
 
     def log_debug(self, message: Any):
+        if logging_level > logging.DEBUG:
+            return
         prefix = self.__get_log_prefix()
         colored_message = colored(
             f'{prefix} • {message}', attrs=['dark']
@@ -103,6 +113,8 @@ class BaseTaskModel(CommonTaskModel, PidModel, TimeTracker):
         logger.debug(colored_message)
 
     def log_warn(self, message: Any):
+        if logging_level > logging.WARNING:
+            return
         prefix = self.__get_log_prefix()
         colored_message = colored(
             f'{prefix} • {message}', attrs=['dark']
@@ -110,6 +122,8 @@ class BaseTaskModel(CommonTaskModel, PidModel, TimeTracker):
         logger.warning(colored_message)
 
     def log_info(self, message: Any):
+        if logging_level > logging.INFO:
+            return
         prefix = self.__get_log_prefix()
         colored_message = colored(
             f'{prefix} • {message}', attrs=['dark']
@@ -117,6 +131,8 @@ class BaseTaskModel(CommonTaskModel, PidModel, TimeTracker):
         logger.info(colored_message)
 
     def log_error(self, message: Any):
+        if logging_level > logging.ERROR:
+            return
         prefix = self.__get_log_prefix()
         colored_message = colored(
             f'{prefix} • {message}', color='red', attrs=['bold']
@@ -124,6 +140,8 @@ class BaseTaskModel(CommonTaskModel, PidModel, TimeTracker):
         logger.error(colored_message, exc_info=True)
 
     def log_critical(self, message: Any):
+        if logging_level > logging.CRITICAL:
+            return
         prefix = self.__get_log_prefix()
         colored_message = colored(
             f'{prefix} • {message}', color='red', attrs=['bold']
@@ -203,13 +221,15 @@ class BaseTaskModel(CommonTaskModel, PidModel, TimeTracker):
     def __get_print_prefix(self) -> str:
         common_prefix = self.__get_common_prefix(show_time=show_time)
         icon = self.get_icon()
-        rjust_cli_name = self.__get_rjust_full_cli_name()
+        length = LOG_NAME_LENGTH - len(icon)
+        rjust_cli_name = self.__get_rjust_full_cli_name(length)
         return f'{common_prefix} {icon} {rjust_cli_name}'
 
     def __get_log_prefix(self) -> str:
         common_prefix = self.__get_common_prefix(show_time=False)
         icon = self.get_icon()
-        filled_name = self.__get_rjust_full_cli_name()
+        length = LOG_NAME_LENGTH - len(icon)
+        filled_name = self.__get_rjust_full_cli_name(length)
         return f'{common_prefix} {icon} {filled_name}'
 
     def __get_common_prefix(self, show_time: bool) -> str:
@@ -221,18 +241,21 @@ class BaseTaskModel(CommonTaskModel, PidModel, TimeTracker):
             return f'◷ {now} ❁ {pid} → {attempt}/{max_attempt}'
         return f'❁ {pid} → {attempt}/{max_attempt}'
 
-    def __get_rjust_full_cli_name(self) -> str:
+    @lru_cache
+    def __get_rjust_full_cli_name(self, length: int) -> str:
         if self.__rjust_full_cli_name is not None:
             return self.__rjust_full_cli_name
         complete_name = self._get_full_cli_name()
-        self.__rjust_full_cli_name = complete_name.rjust(LOG_NAME_LENGTH, ' ')
+        self.__rjust_full_cli_name = complete_name.rjust(length, ' ')
         return self.__rjust_full_cli_name
 
+    @lru_cache
     def __get_executable_name(self) -> str:
         if len(sys.argv) > 0 and sys.argv[0] != '':
             return os.path.basename(sys.argv[0])
         return 'zrb'
 
+    @lru_cache
     def _get_full_cli_name(self) -> str:
         if self.__complete_name is not None:
             return self.__complete_name

zrb/task/base_task/component/common_task_model.py

@@ -60,7 +60,7 @@ class CommonTaskModel():
         self._retry = retry
         self._retry_interval = retry_interval
         self._upstreams = upstreams
-        self._checkers = checkers
+        self._checkers = [checker.copy() for checker in checkers]
         self._checking_interval = checking_interval
         self._run_function: Optional[Callable[..., Any]] = run
         self._on_triggered = on_triggered
@@ -77,10 +77,10 @@ class CommonTaskModel():
         self.__allow_add_env_files = True
         self.__allow_add_inputs = True
         self.__allow_add_upstreams: 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_checkers: bool = False
         self.__has_already_inject_upstreams: bool = False
         self.__all_inputs: Optional[List[AnyInput]] = None
 
@@ -104,12 +104,15 @@ class CommonTaskModel():
         return self.__execution_id
 
     def set_name(self, new_name: str):
-        if self._description == self._name:
+        if self._description == self.get_name():
             self._description = new_name
         self._name = new_name
 
+    def get_name(self) -> str:
+        return self._name
+
     def get_cli_name(self) -> str:
-        return to_cli_name(self._name)
+        return to_cli_name(self.get_name())
 
     def set_description(self, new_description: str):
         self._description = new_description
@@ -139,12 +142,12 @@ class CommonTaskModel():
 
     def insert_input(self, *inputs: AnyInput):
         if not self.__allow_add_inputs:
-            raise Exception(f'Cannot insert inputs for `{self._name}`')
+            raise Exception(f'Cannot insert inputs for `{self.get_name()}`')
         self._inputs = list(inputs) + list(self._inputs)
 
     def add_input(self, *inputs: AnyInput):
         if not self.__allow_add_inputs:
-            raise Exception(f'Cannot add inputs for `{self._name}`')
+            raise Exception(f'Cannot add inputs for `{self.get_name()}`')
         self._inputs = list(self._inputs) + list(inputs)
 
     def inject_inputs(self):
@@ -194,12 +197,12 @@ class CommonTaskModel():
 
     def insert_env(self, *envs: Env):
         if not self.__allow_add_envs:
-            raise Exception(f'Cannot insert envs to `{self._name}`')
+            raise Exception(f'Cannot insert envs to `{self.get_name()}`')
         self._envs = list(envs) + list(self._envs)
 
     def add_env(self, *envs: Env):
         if not self.__allow_add_envs:
-            raise Exception(f'Cannot add envs to `{self._name}`')
+            raise Exception(f'Cannot add envs to `{self.get_name()}`')
         self._envs = list(self._envs) + list(envs)
 
     def inject_envs(self):
@@ -230,12 +233,12 @@ class CommonTaskModel():
 
     def insert_env_file(self, *env_files: EnvFile):
         if not self.__allow_add_env_files:
-            raise Exception(f'Cannot insert env_files to `{self._name}`')
+            raise Exception(f'Cannot insert env_files to `{self.get_name()}`')
         self._env_files = list(env_files) + list(self._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._name}`')
+            raise Exception(f'Cannot add env_files to `{self.get_name()}`')
         self._env_files = list(self._env_files) + list(env_files)
 
     def inject_env_files(self):
@@ -243,12 +246,12 @@ class CommonTaskModel():
 
     def insert_upstream(self, *upstreams: AnyTask):
         if not self.__allow_add_upstreams:
-            raise Exception(f'Cannot insert upstreams to `{self._name}`')
+            raise Exception(f'Cannot insert upstreams to `{self.get_name()}`')
         self._upstreams = list(upstreams) + list(self._upstreams)
 
     def add_upstream(self, *upstreams: AnyTask):
         if not self.__allow_add_upstreams:
-            raise Exception(f'Cannot add upstreams to `{self._name}`')
+            raise Exception(f'Cannot add upstreams to `{self.get_name()}`')
         self._upstreams = list(self._upstreams) + list(upstreams)
 
     def inject_upstreams(self):
@@ -272,11 +275,23 @@ class CommonTaskModel():
             self.__has_already_inject_env_files = True
         return self._env_files
 
+    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]
+        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]
+        self._checkers = self._checkers + additional_checkers
+
     def inject_checkers(self):
         pass
 
     def _get_checkers(self) -> List[AnyTask]:
-        if not self.__has_already_inject_checkers:
+        if not self.__allow_add_checkers:
             self.inject_checkers()
-            self.__has_already_inject_checkers = True
-        return list(self._checkers)
+            self.__allow_add_checkers = True
+        return self._checkers

zrb/task/base_task/component/renderer.py

@@ -1,3 +1,4 @@
+from zrb.task.any_task import AnyTask
 from zrb.helper.typing import Any, JinjaTemplate, Mapping, Optional, Union
 from zrb.helper.typecheck import typechecked
 from zrb.helper.string.conversion import to_boolean
@@ -24,10 +25,14 @@ class Renderer():
 
     def __init__(self):
         self.__input_map: Mapping[str, Any] = {}
+        self.__task: Optional[AnyTask] = None
         self.__env_map: Mapping[str, str] = {}
         self.__render_data: Optional[Mapping[str, Any]] = None
         self.__rendered_str: Mapping[str, str] = {}
 
+    def _set_task(self, task: AnyTask):
+        self.__task = task
+
     def get_input_map(self) -> Mapping[str, Any]:
         # This return reference to input map, so input map can be updated
         return self.__input_map
@@ -126,6 +131,7 @@ class Renderer():
         render_data.update({
             'env': self.__env_map,
             'input': self.__input_map,
+            'task': self.__task,
         })
         self.__render_data = render_data
         return render_data

zrb/task/cmd_task.py

@@ -48,6 +48,9 @@ class CmdResult():
         self.output = output
         self.error = error
 
+    def __str__(self) -> str:
+        return self.output
+
 
 class CmdGlobalState():
     def __init__(self):
@@ -61,30 +64,18 @@ class CmdTask(BaseTask):
     Command Task.
     You can use this task to run shell command.
 
-    For example:
-    ```python
-    # run a simple task
-    hello = CmdTask(
-        name='hello',
-        inputs=[StrInput(name='name', default='World')],
-        envs=[Env(name='HOME_DIR', os_name='HOME')],
-        cmd=[
-            'echo Hello {{ input.name }}',
-            'echo Home directory is: $HOME_DIR',
-        ]
-    )
-    runner.register(hello)
-
-    # run a long running process
-    run_server = CmdTask(
-        name='run',
-        inputs=[StrInput(name='dir', default='.')],
-        envs=[Env(name='PORT', os_name='WEB_PORT', default='3000')],
-        cmd='python -m http.server $PORT --directory {{input.dir}}',
-        checkers=[HTTPChecker(port='{{env.PORT}}')]
-    )
-    runner.register(run_server)
-    ```
+    Examples:
+        >>> from zrb import runner, CmdTask, StrInput, Env
+        >>> hello = CmdTask(
+        >>>     name='hello',
+        >>>     inputs=[StrInput(name='name', default='World')],
+        >>>     envs=[Env(name='HOME_DIR', os_name='HOME')],
+        >>>     cmd=[
+        >>>         'echo Hello {{ input.name }}',
+        >>>         'echo Home directory is: $HOME_DIR',
+        >>>     ]
+        >>> )
+        >>> runner.register(hello)
     '''
 
     _pids: List[int] = []
@@ -246,6 +237,8 @@ class CmdTask(BaseTask):
             raise Exception(
                 f'Process {self._name} exited ({return_code}): {error}'
             )
+        self.set_task_xcom(key='output', value=output)
+        self.set_task_xcom(key='error', value=error)
         return CmdResult(output, error)
 
     def _should_attempt(self) -> bool:

zrb/task/docker_compose_task.py

@@ -293,7 +293,6 @@ class DockerComposeTask(CmdTask):
             ]:
                 if os.path.exists(os.path.join(self._cwd, _compose_file)):
                     return os.path.join(self._cwd, _compose_file)
-                    return
             raise Exception(f'Cannot find compose file on {self._cwd}')
         if os.path.isabs(compose_file) and os.path.exists(compose_file):
             return compose_file

zrb/task/path_checker.py

@@ -1,5 +1,8 @@
-from zrb.helper.typing import Any, Callable, Iterable, Optional, Union, TypeVar
+from zrb.helper.typing import (
+    Any, Callable, Iterable, List, Optional, Union, TypeVar
+)
 from zrb.helper.typecheck import typechecked
+from zrb.helper.file.match import get_file_names
 from zrb.task.checker import Checker
 from zrb.task.any_task import AnyTask
 from zrb.task.any_task_event_handler import (
@@ -10,8 +13,6 @@ from zrb.task_env.env_file import EnvFile
 from zrb.task_group.group import Group
 from zrb.task_input.any_input import AnyInput
 
-import glob
-
 TPathChecker = TypeVar('TPathChecker', bound='PathChecker')
 
 
@@ -37,6 +38,7 @@ class PathChecker(Checker):
         on_retry: Optional[OnRetry] = None,
         on_failed: Optional[OnFailed] = None,
         path: str = '',
+        ignored_path: Union[str, Iterable[str]] = [],
         checking_interval: Union[int, float] = 0.1,
         progress_interval: Union[int, float] = 5,
         expected_result: bool = True,
@@ -66,7 +68,9 @@ class PathChecker(Checker):
             should_execute=should_execute,
         )
         self._path = path
+        self._ignored_path = ignored_path
         self._rendered_path: str = ''
+        self._rendered_ignored_paths: List[str] = []
 
     def copy(self) -> TPathChecker:
         return super().copy()
@@ -84,12 +88,29 @@ class PathChecker(Checker):
 
     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 != ''
+        ]
         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
+        ]
+
     async def inspect(self, *args: Any, **kwargs: Any) -> bool:
         label = f'Checking {self._rendered_path}'
         try:
-            if len(glob.glob(self._rendered_path, recursive=True)) > 0:
+            matches = get_file_names(
+                glob_path=self._rendered_path,
+                glob_ignored_paths=self._rendered_ignored_paths
+            )
+            if len(matches) > 0:
                 self.print_out(f'{label} (Exist)')
                 return True
             self.show_progress(f'{label} (Not Exist)')

zrb/task/path_watcher.py

@@ -1,7 +1,8 @@
 from zrb.helper.typing import (
-    Any, Callable, Iterable, Mapping, Optional, Union, TypeVar
+    Any, Callable, Iterable, List, Mapping, Optional, Union, TypeVar
 )
 from zrb.helper.typecheck import typechecked
+from zrb.helper.file.match import get_file_names
 from zrb.task.checker import Checker
 from zrb.task.any_task import AnyTask
 from zrb.task.any_task_event_handler import (
@@ -12,7 +13,6 @@ from zrb.task_env.env_file import EnvFile
 from zrb.task_group.group import Group
 from zrb.task_input.any_input import AnyInput
 
-import glob
 import os
 
 TPathWatcher = TypeVar('TPathWatcher', bound='PathWatcher')
@@ -20,6 +20,16 @@ TPathWatcher = TypeVar('TPathWatcher', bound='PathWatcher')
 
 @typechecked
 class PathWatcher(Checker):
+    '''
+    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
+    '''
 
     def __init__(
         self,
@@ -40,6 +50,7 @@ class PathWatcher(Checker):
         on_retry: Optional[OnRetry] = None,
         on_failed: Optional[OnFailed] = None,
         path: str = '',
+        ignored_path: Union[str, Iterable[str]] = [],
         checking_interval: Union[int, float] = 0.1,
         progress_interval: Union[int, float] = 30,
         watch_new_files: bool = True,
@@ -70,10 +81,12 @@ class PathWatcher(Checker):
             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] = []
         self._init_times: Mapping[str, float] = {}
 
     def copy(self) -> TPathWatcher:
@@ -92,25 +105,43 @@ class PathWatcher(Checker):
 
     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 != ''
+        ]
         self._init_times = 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
+        ]
+
     async def inspect(self, *args: Any, **kwargs: Any) -> bool:
         label = f'Watching {self._rendered_path}'
         try:
             mod_times = self._get_mod_times()
-        except Exception:
+        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() - self._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)
                 return True
         if self._watch_deleted_files:
             deleted_files = self._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)
                 return True
         if self._watch_modified_files:
             modified_files = {
@@ -119,12 +150,22 @@ class PathWatcher(Checker):
             }
             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)
                 return True
         self.show_progress(f'{label} (Nothing changed)')
         return False
 
     def _get_mod_times(self) -> Mapping[str, float]:
-        return {
-            file_name: os.stat(file_name).st_mtime
-            for file_name in glob.glob(self._rendered_path, recursive=True)
-        }
+        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/recurring_task.py

@@ -8,7 +8,6 @@ from zrb.task.any_task import AnyTask
 from zrb.task.any_task_event_handler import (
     OnTriggered, OnWaiting, OnSkipped, OnStarted, OnReady, OnRetry, OnFailed
 )
-from zrb.task.task import Task
 from zrb.task_env.env import Env
 from zrb.task_env.env_file import EnvFile
 from zrb.task_group.group import Group
@@ -18,14 +17,40 @@ import asyncio
 import copy
 
 
+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] = [],
@@ -80,6 +105,8 @@ class RecurringTask(BaseTask):
         self._triggers: List[AnyTask] = [
             trigger.copy() for trigger in triggers
         ]
+        self._run_configs: List[RunConfig] = []
+        self._single_execution = single_execution
 
     async def _set_keyval(self, kwargs: Mapping[str, Any], env_prefix: str):
         await super()._set_keyval(kwargs=kwargs, env_prefix=env_prefix)
@@ -97,6 +124,12 @@ class RecurringTask(BaseTask):
         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']
@@ -138,13 +171,31 @@ class RecurringTask(BaseTask):
             fn = task_copy.to_function(
                 is_async=True, raise_error=False, show_done_info=False
             )
-            self.print_out_dark('Executing the task')
-            asyncio.create_task(
-                self.__run_and_play_bell(fn, *args, **task_kwargs)
+            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_and_play_bell(
-        self, fn: Callable[..., Any], *args: Any, **kwargs: Any
-    ):
-        await fn(*args, **kwargs)
-        self._play_bell()
+    async def __run_from_queue(self):
+        while True:
+            if len(self._run_configs) == 0:
+                await asyncio.sleep(0.1)
+                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/time_watcher.py

@@ -20,6 +20,12 @@ TTimeWatcher = TypeVar('TTimeWatcher', bound='TimeWatcher')
 
 @typechecked
 class TimeWatcher(Checker):
+    '''
+    TimeWatcher will wait for any changes specified on  path.
+
+    Once the changes detected, TimeWatcher will be completed
+    and <task-name>.scheduled-time xcom will be set.
+    '''
 
     def __init__(
         self,
@@ -92,6 +98,7 @@ class TimeWatcher(Checker):
             self._rendered_schedule, slightly_before_check_time
         )
         self._scheduled_time = cron.get_next(datetime.datetime)
+        self.set_task_xcom(key='scheduled-time', value=self._scheduled_time)
         return await super().run(*args, **kwargs)
 
     async def inspect(self, *args: Any, **kwargs: Any) -> bool: