zrb 0.0.117__py3-none-any.whl → 0.0.119__py3-none-any.whl

zrb/task/base_task/component/trackers.py

@@ -0,0 +1,76 @@
+from zrb.helper.typing import Optional
+from zrb.helper.typecheck import typechecked
+
+import asyncio
+import time
+
+LOG_NAME_LENGTH = 20
+
+
+@typechecked
+class TimeTracker():
+
+    def __init__(self):
+        self.__start_time: float = 0
+        self.__end_time: float = 0
+
+    def _start_timer(self):
+        self.__start_time = time.time()
+
+    def _end_timer(self):
+        self.__end_time = time.time()
+
+    def _get_elapsed_time(self) -> float:
+        return self.__end_time - self.__start_time
+
+
+@typechecked
+class AttemptTracker():
+
+    def __init__(self, retry: int = 2):
+        self.__retry = retry
+        self.__attempt: int = 1
+
+    def _get_max_attempt(self) -> int:
+        return self.__retry + 1
+
+    def _get_attempt(self) -> int:
+        return self.__attempt
+
+    def _increase_attempt(self):
+        self.__attempt += 1
+
+    def _should_attempt(self) -> bool:
+        attempt = self._get_attempt()
+        max_attempt = self._get_max_attempt()
+        return attempt <= max_attempt
+
+    def _is_last_attempt(self) -> bool:
+        attempt = self._get_attempt()
+        max_attempt = self._get_max_attempt()
+        return attempt >= max_attempt
+
+
+@typechecked
+class FinishTracker():
+
+    def __init__(self):
+        self.__execution_queue: Optional[asyncio.Queue] = None
+        self.__counter = 0
+
+    async def _mark_awaited(self):
+        if self.__execution_queue is None:
+            self.__execution_queue = asyncio.Queue()
+        self.__counter += 1
+
+    async def _mark_done(self):
+        # Tracker might be started several times
+        # However, when the execution is marked as done, it applied globally
+        # Thus, we need to send event as much as the counter.
+        for i in range(self.__counter):
+            await self.__execution_queue.put(True)
+
+    async def _is_done(self) -> bool:
+        while self.__execution_queue is None:
+            await asyncio.sleep(0.05)
+        return await self.__execution_queue.get()

zrb/task/checker.py

@@ -1,6 +1,6 @@
 from zrb.helper.typing import Any, Callable, Iterable, Optional, Union
 from zrb.helper.typecheck import typechecked
-from zrb.task.base_task import BaseTask
+from zrb.task.base_task.base_task import BaseTask
 from zrb.task.any_task import AnyTask
 from zrb.task.any_task_event_handler import (
     OnTriggered, OnWaiting, OnSkipped, OnStarted, OnReady, OnRetry, OnFailed
@@ -87,3 +87,6 @@ class Checker(BaseTask):
             self.print_out_dark(message)
             return
         self.log_debug(message)
+
+    def __repr__(self) -> str:
+        return f'<Checker name={self._name}>'

zrb/task/cmd_task.py

@@ -2,11 +2,12 @@ from zrb.helper.typing import (
     Any, Callable, Iterable, List, Optional, Union, TypeVar
 )
 from zrb.helper.typecheck import typechecked
+from zrb.helper.string.conversion import to_variable_name
 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.base_task import BaseTask
+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
@@ -150,7 +151,7 @@ class CmdTask(BaseTask):
         max_error_line = max_error_line if max_error_line > 0 else 1
         self._cmd = cmd
         self._cmd_path = cmd_path
-        self._set_cwd(cwd)
+        self.__set_cwd(cwd)
         self._max_output_size = max_output_line
         self._max_error_size = max_error_line
         self._output_buffer: Iterable[str] = []
@@ -164,7 +165,10 @@ class CmdTask(BaseTask):
     def copy(self) -> TCmdTask:
         return super().copy()
 
-    def _set_cwd(
+    def set_cwd(self, cwd: Union[str, pathlib.Path]):
+        self.__set_cwd(cwd)
+
+    def __set_cwd(
         self, cwd: Optional[Union[str, pathlib.Path]]
     ):
         if cwd is None:
@@ -192,7 +196,7 @@ class CmdTask(BaseTask):
         super().inject_envs()
         input_map = self.get_input_map()
         for task_input in self._get_combined_inputs():
-            input_key = self._get_normalized_input_key(task_input.get_name())
+            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()
@@ -205,7 +209,7 @@ class CmdTask(BaseTask):
 
     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('Run script: ' + self.__get_multiline_repr(cmd))
         self.print_out_dark('Working directory: ' + self._cwd)
         self._output_buffer = []
         self._error_buffer = []
@@ -225,14 +229,14 @@ class CmdTask(BaseTask):
         self._pids.append(process.pid)
         self._process = process
         try:
-            signal.signal(signal.SIGINT, self._on_kill)
-            signal.signal(signal.SIGTERM, self._on_kill)
+            signal.signal(signal.SIGINT, self.__on_kill)
+            signal.signal(signal.SIGTERM, self.__on_kill)
         except Exception as e:
             self.print_err(e)
-        atexit.register(self._on_exit)
-        await self._wait_process(process)
+        atexit.register(self.__on_exit)
+        await self.__wait_process(process)
         self.log_info('Process completed')
-        atexit.unregister(self._on_exit)
+        atexit.unregister(self.__on_exit)
         output = '\n'.join(self._output_buffer)
         error = '\n'.join(self._error_buffer)
         # get return code
@@ -254,36 +258,42 @@ class CmdTask(BaseTask):
             return True
         return super()._is_last_attempt()
 
-    def _on_kill(self, signum: Any, frame: Any):
+    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}')
         for pid in self._pids:
-            self._kill_by_pid(pid)
-        self.print_out_dark(f'Exiting with signal {signum}')
+            self.__kill_by_pid(pid)
+        tasks = asyncio.all_tasks()
+        for task in tasks:
+            try:
+                task.cancel()
+            except Exception as e:
+                self.print_err(e)
         time.sleep(0.3)
+        self.print_out_dark(f'Exiting with signal {signum}')
         sys.exit(signum)
 
-    def _on_exit(self):
+    def __on_exit(self):
         self._global_state.no_more_attempt = True
-        self._kill_by_pid(self._process.pid)
+        self.__kill_by_pid(self._process.pid)
 
-    def _kill_by_pid(self, pid: int):
+    def __kill_by_pid(self, pid: int):
         '''
         Kill a pid, gracefully
         '''
         try:
             process_ever_exists = False
-            if self._is_process_exist(pid):
+            if self.__is_process_exist(pid):
                 process_ever_exists = True
                 self.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):
+            if self.__is_process_exist(pid):
                 self.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):
+            if self.__is_process_exist(pid):
                 self.print_out_dark(f'Send SIGKILL to process {pid}')
                 os.killpg(os.getpgid(pid), signal.SIGKILL)
             if process_ever_exists:
@@ -291,30 +301,30 @@ class CmdTask(BaseTask):
         except Exception:
             self.log_error(f'Cannot kill process {pid}')
 
-    def _is_process_exist(self, pid: int) -> bool:
+    def __is_process_exist(self, pid: int) -> bool:
         try:
             os.killpg(os.getpgid(pid), 0)
             return True
         except ProcessLookupError:
             return False
 
-    async def _wait_process(self, process: asyncio.subprocess.Process):
+    async def __wait_process(self, process: asyncio.subprocess.Process):
         # Create queue
         stdout_queue = asyncio.Queue()
         stderr_queue = asyncio.Queue()
         # Read from streams and put into queue
-        stdout_process = asyncio.create_task(self._queue_stream(
+        stdout_process = asyncio.create_task(self.__queue_stream(
             process.stdout, stdout_queue
         ))
-        stderr_process = asyncio.create_task(self._queue_stream(
+        stderr_process = asyncio.create_task(self.__queue_stream(
             process.stderr, stderr_queue
         ))
         # Handle messages in queue
-        stdout_log_process = asyncio.create_task(self._log_from_queue(
+        stdout_log_process = asyncio.create_task(self.__log_from_queue(
             stdout_queue, self.print_out,
             self._output_buffer, self._max_output_size
         ))
-        stderr_log_process = asyncio.create_task(self._log_from_queue(
+        stderr_log_process = asyncio.create_task(self.__log_from_queue(
             stderr_queue, self.print_err,
             self._error_buffer, self._max_error_size
         ))
@@ -338,13 +348,13 @@ class CmdTask(BaseTask):
     ) -> str:
         if not isinstance(cmd_path, str) or cmd_path != '':
             if callable(cmd_path):
-                return self._get_rendered_cmd_path(cmd_path(*args, **kwargs))
-            return self._get_rendered_cmd_path(cmd_path)
+                return self.__get_rendered_cmd_path(cmd_path(*args, **kwargs))
+            return self.__get_rendered_cmd_path(cmd_path)
         if callable(cmd):
-            return self._get_rendered_cmd(cmd(*args, **kwargs))
-        return self._get_rendered_cmd(cmd)
+            return self.__get_rendered_cmd(cmd(*args, **kwargs))
+        return self.__get_rendered_cmd(cmd)
 
-    def _get_rendered_cmd_path(
+    def __get_rendered_cmd_path(
         self, cmd_path: Union[str, Iterable[str]]
     ) -> str:
         if isinstance(cmd_path, str):
@@ -354,12 +364,12 @@ class CmdTask(BaseTask):
             for cmd_path_str in cmd_path
         ])
 
-    def _get_rendered_cmd(self, cmd: Union[str, Iterable[str]]) -> str:
+    def __get_rendered_cmd(self, cmd: Union[str, Iterable[str]]) -> str:
         if isinstance(cmd, str):
             return self.render_str(cmd)
         return self.render_str('\n'.join(list(cmd)))
 
-    async def _queue_stream(self, stream, queue: asyncio.Queue):
+    async def __queue_stream(self, stream, queue: asyncio.Queue):
         while True:
             try:
                 line = await stream.readline()
@@ -369,7 +379,7 @@ class CmdTask(BaseTask):
                 break
             await queue.put(line)
 
-    async def _log_from_queue(
+    async def __log_from_queue(
         self,
         queue: asyncio.Queue,
         print_log: Callable[[str], None],
@@ -381,17 +391,27 @@ class CmdTask(BaseTask):
             if not line:
                 break
             line_str = line.decode('utf-8').rstrip()
-            self._add_to_buffer(buffer, max_size, line_str)
+            self.__add_to_buffer(buffer, max_size, line_str)
             _reset_stty()
             print_log(line_str)
             _reset_stty()
 
-    def _add_to_buffer(
+    def __add_to_buffer(
         self, buffer: Iterable[str], max_size: int, new_line: str
     ):
         if len(buffer) >= max_size:
             buffer.pop(0)
         buffer.append(new_line)
-    
+
+    def __get_multiline_repr(self, text: str) -> str:
+        lines_repr: Iterable[str] = []
+        lines = text.split('\n')
+        if len(lines) == 1:
+            return lines[0]
+        for index, line in enumerate(lines):
+            line_number_repr = str(index + 1).rjust(4, '0')
+            lines_repr.append(f'        {line_number_repr} | {line}')
+        return '\n' + '\n'.join(lines_repr)
+
     def __repr__(self) -> str:
         return f'<CmdTask name={self._name}>'

zrb/task/docker_compose_task.py

@@ -145,10 +145,10 @@ class DockerComposeTask(CmdTask):
         self._compose_flags = compose_flags
         self._compose_args = compose_args
         self._compose_env_prefix = compose_env_prefix
-        self._compose_template_file = self._get_compose_template_file(
+        self._compose_template_file = self.__get_compose_template_file(
             compose_file
         )
-        self._compose_runtime_file = self._get_compose_runtime_file(
+        self._compose_runtime_file = self.__get_compose_runtime_file(
             self._compose_template_file
         )
         # Flag to make mark whether service config and compose environments
@@ -160,7 +160,7 @@ class DockerComposeTask(CmdTask):
         return super().copy()
 
     async def run(self, *args, **kwargs: Any) -> CmdResult:
-        self._generate_compose_runtime_file()
+        self.__generate_compose_runtime_file()
         try:
             result = await super().run(*args, **kwargs)
         finally:
@@ -192,7 +192,7 @@ class DockerComposeTask(CmdTask):
         for _, service_config in self._compose_service_configs.items():
             self.insert_env_file(*service_config.get_env_files())
 
-    def _generate_compose_runtime_file(self):
+    def __generate_compose_runtime_file(self):
         compose_data = read_compose_file(self._compose_template_file)
         for service, service_config in self._compose_service_configs.items():
             envs: List[Env] = []
@@ -200,10 +200,12 @@ class DockerComposeTask(CmdTask):
             for env_file in env_files:
                 envs += env_file.get_envs()
             envs += service_config.get_envs()
-            compose_data = self._apply_service_env(compose_data, service, envs)
+            compose_data = self.__apply_service_env(
+                compose_data, service, envs
+            )
         write_compose_file(self._compose_runtime_file, compose_data)
 
-    def _apply_service_env(
+    def __apply_service_env(
         self, compose_data: Any, service: str, envs: List[Env]
     ) -> Any:
         # service not found
@@ -213,12 +215,13 @@ class DockerComposeTask(CmdTask):
         # service has no environment definition
         if 'environment' not in compose_data['services'][service]:
             compose_data['services'][service]['environment'] = {
-                env.name: self._get_env_compose_value(env) for env in envs
+                env.get_name(): self.__get_env_compose_value(env)
+                for env in envs
             }
             return compose_data
         # service environment is a map
         if isinstance(compose_data['services'][service]['environment'], dict):
-            new_env_map = self._get_service_new_env_map(
+            new_env_map = self.__get_service_new_env_map(
                 compose_data['services'][service]['environment'], envs
             )
             for key, value in new_env_map.items():
@@ -226,43 +229,44 @@ class DockerComposeTask(CmdTask):
             return compose_data
         # service environment is a list
         if isinstance(compose_data['services'][service]['environment'], list):
-            new_env_list = self._get_service_new_env_list(
+            new_env_list = self.__get_service_new_env_list(
                 compose_data['services'][service]['environment'], envs
             )
             compose_data['services'][service]['environment'] += new_env_list
             return compose_data
         return compose_data
 
-    def _get_service_new_env_map(
+    def __get_service_new_env_map(
         self, service_env_map: Mapping[str, str], new_envs: List[Env]
     ) -> Mapping[str, str]:
         new_service_envs: Mapping[str, str] = {}
         for env in new_envs:
-            if env.name in service_env_map:
+            env_name = env.get_name()
+            if env_name in service_env_map:
                 continue
-            new_service_envs[env.name] = self._get_env_compose_value(env)
+            new_service_envs[env_name] = self.__get_env_compose_value(env)
         return new_service_envs
 
-    def _get_service_new_env_list(
+    def __get_service_new_env_list(
         self, service_env_list: List[str], new_envs: List[Env]
     ) -> List[str]:
         new_service_envs: List[str] = []
         for env in new_envs:
             should_be_added = 0 == len([
                 service_env for service_env in service_env_list
-                if service_env.startswith(env.name + '=')
+                if service_env.startswith(env.get_name() + '=')
             ])
             if not should_be_added:
                 continue
             new_service_envs.append(
-                env.name + '=' + self._get_env_compose_value(env)
+                env.get_name() + '=' + self.__get_env_compose_value(env)
             )
         return new_service_envs
 
-    def _get_env_compose_value(self, env: Env) -> str:
-        return '${' + env.name + ':-' + env.default + '}'
+    def __get_env_compose_value(self, env: Env) -> str:
+        return '${' + env.get_name() + ':-' + env.get_default() + '}'
 
-    def _get_compose_runtime_file(self, compose_file_name: str) -> str:
+    def __get_compose_runtime_file(self, compose_file_name: str) -> str:
         directory, file = os.path.split(compose_file_name)
         prefix = '_' if file.startswith('.') else '._'
         runtime_prefix = self.get_cmd_name()
@@ -281,7 +285,7 @@ class DockerComposeTask(CmdTask):
         runtime_file_name = prefix + file + runtime_prefix
         return os.path.join(directory, runtime_file_name)
 
-    def _get_compose_template_file(self, compose_file: Optional[str]) -> str:
+    def __get_compose_template_file(self, compose_file: Optional[str]) -> str:
         if compose_file is None:
             for _compose_file in [
                 'compose.yml', 'compose.yaml',

zrb/task/flow_task.py

@@ -2,7 +2,7 @@ from zrb.helper.typing import (
     Callable, Iterable, List, Optional, TypeVar, Union
 )
 from zrb.helper.typecheck import typechecked
-from zrb.task.base_task import BaseTask
+from zrb.task.base_task.base_task import BaseTask
 from zrb.task.any_task import AnyTask
 from zrb.task.any_task_event_handler import (
     OnTriggered, OnWaiting, OnSkipped, OnStarted, OnReady, OnRetry, OnFailed

zrb/task/notifier.py

@@ -0,0 +1,157 @@
+from zrb.helper.typing import Any, Callable, Iterable, Optional, Union
+from zrb.helper.typecheck import typechecked
+from zrb.task.base_task.base_task import BaseTask
+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_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
+from zrb.helper.accessories.icon import get_random_icon
+from zrb.helper.string.modification import double_quote
+
+import os
+import subprocess
+
+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'
+)))
+
+
+@typechecked
+class Notifier(BaseTask):
+    def __init__(
+        self,
+        name: str = 'port-check',
+        group: Optional[Group] = None,
+        inputs: Iterable[AnyInput] = [],
+        envs: Iterable[Env] = [],
+        env_files: Iterable[EnvFile] = [],
+        icon: Optional[str] = None,
+        color: Optional[str] = None,
+        description: str = '',
+        title: str = '',
+        message: str = '',
+        show_toast: bool = True,
+        show_stdout: bool = True,
+        upstreams: 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,
+        retry: int = 2,
+        retry_interval: Union[float, int] = 1,
+        should_execute: Union[bool, str, Callable[..., bool]] = True
+    ):
+        BaseTask.__init__(
+            self,
+            name=name,
+            group=group,
+            inputs=inputs,
+            envs=envs,
+            env_files=env_files,
+            icon=icon,
+            color=color,
+            description=description,
+            upstreams=upstreams,
+            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=[],
+            checking_interval=checking_interval,
+            retry=retry,
+            retry_interval=retry_interval,
+            should_execute=should_execute,
+        )
+        self._title = title if title != '' else name
+        self._message = message if message != '' else get_random_icon()
+        self._show_toast = show_toast
+        self._show_stdout = show_stdout
+
+    async def run(self, *args: Any, **kwargs: Any) -> str:
+        title = self.render_str(self._title)
+        message = self.render_str(self._message)
+        notify_kwargs = {
+            key: value
+            for key, value in kwargs.items() if key not in ('title', 'message')
+        }
+        await self.notify(title, message, **notify_kwargs)
+        return message
+
+    async def notify(self, title: str, message: str, **kwargs: Any) -> None:
+        task: BaseTask = kwargs.get('_task')
+        if self._show_toast and _is_powershell_available():
+            cmd = [
+                'powershell.exe',
+                '-ExecutionPolicy', 'Bypass',
+                '-File', NOTIFY_PS1_PATH,
+                '-Title', title,
+                '-Message', message
+            ]
+            subprocess.run(cmd, stdout=subprocess.DEVNULL)
+        if self._show_toast and _is_osascript_available():
+            q_message = double_quote(message)
+            q_title = double_quote(title)
+            cmd = [
+                'osascript',
+                '-e',
+                f'display notification "{q_message}" with title "{q_title}"'
+            ]
+        if self._show_toast and _is_notify_send_available():
+            cmd = ['notify-send', title, message]
+            subprocess.run(cmd, stdout=subprocess.DEVNULL)
+        if self._show_stdout:
+            task.print_out(message)
+            task._play_bell()
+
+    def __repr__(self) -> str:
+        return f'<Notifier name={self._name}>'
+
+
+def _is_powershell_available():
+    try:
+        subprocess.run(
+            ['powershell.exe', '-Command', 'echo "Checking PowerShell"'],
+            check=True, stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL
+        )
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError, PermissionError):
+        return False
+
+
+def _is_notify_send_available():
+    try:
+        subprocess.run(
+            ['notify-send', '--version'],
+            check=True,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL
+        )
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError, PermissionError):
+        return False
+
+
+def _is_osascript_available():
+    try:
+        subprocess.run(
+            ['osascript', '-e', 'return'],
+            check=True,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL
+        )
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError, PermissionError):
+        return False

zrb/task/recurring_task.py

@@ -2,7 +2,7 @@ from zrb.helper.typing import (
     Any, Callable, Iterable, Mapping, Optional, Union
 )
 from zrb.helper.typecheck import typechecked
-from zrb.task.base_task import BaseTask
+from zrb.task.base_task.base_task import BaseTask
 from zrb.task.any_task import AnyTask
 from zrb.task.any_task_event_handler import (
     OnTriggered, OnWaiting, OnSkipped, OnStarted, OnReady, OnRetry, OnFailed
@@ -46,7 +46,7 @@ class RecurringTask(BaseTask):
         should_execute: Union[bool, str, Callable[..., bool]] = True,
         return_upstream_result: bool = False
     ):
-        inputs = list(inputs) + task._get_inputs()
+        inputs = list(inputs) + task._get_combined_inputs()
         envs = list(envs) + task._get_envs()
         env_files = list(env_files) + task._get_env_files()
         BaseTask.__init__(
@@ -97,6 +97,7 @@ class RecurringTask(BaseTask):
             key: kwargs[key]
             for key in kwargs if key not in ['_task']
         }
+        is_first_time = True
         while True:
             # Create trigger functions
             trigger_functions = []
@@ -107,8 +108,12 @@ class RecurringTask(BaseTask):
                 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
-            self.print_out_dark('Waiting for trigger')
             _, pending = await asyncio.wait(
                 trigger_functions, return_when=asyncio.FIRST_COMPLETED
             )
@@ -123,5 +128,15 @@ class RecurringTask(BaseTask):
                 is_async=True, raise_error=False, show_done_info=False
             )
             self.print_out_dark('Executing the task')
-            asyncio.create_task(fn(*args, **task_kwargs))
-            self._play_bell()
+            asyncio.create_task(
+                self.__run_and_play_bell(fn, *args, **task_kwargs)
+            )
+
+    async def __run_and_play_bell(
+        self, fn: Callable[[Any], Any], *args: Any, **kwargs: Any
+    ):
+        await fn(*args, **kwargs)
+        self._play_bell()
+
+    def __repr__(self) -> str:
+        return f'<RecurringTask name={self._name}>'

zrb/task/resource_maker.py

@@ -2,7 +2,7 @@ from zrb.helper.typing import (
     Any, Callable, Iterable, Mapping, Optional, Union, TypeVar
 )
 from zrb.helper.typecheck import typechecked
-from zrb.task.base_task import BaseTask
+from zrb.task.base_task.base_task import BaseTask
 from zrb.task.any_task import AnyTask
 from zrb.task.any_task_event_handler import (
     OnTriggered, OnWaiting, OnSkipped, OnStarted, OnReady, OnRetry, OnFailed