zrb 0.15.1__py3-none-any.whl → 0.17.0__py3-none-any.whl

zrb/__init__.py

@@ -32,8 +32,10 @@ from zrb.task.resource_maker import (
     get_default_resource_skip_parsing,
 )
 from zrb.task.rsync_task import RsyncTask
+from zrb.task.server import Controller, Server
 from zrb.task.task import Task
 from zrb.task.time_watcher import TimeWatcher
+from zrb.task.watcher import Watcher
 from zrb.task.wiki_task import create_wiki_tasks
 from zrb.task_env.env import Env
 from zrb.task_env.env_file import EnvFile
@@ -74,6 +76,9 @@ assert HTTPChecker
 assert PortChecker
 assert PathChecker
 assert PathWatcher
+assert Controller
+assert Server
+assert Watcher
 assert TimeWatcher
 assert ResourceMaker
 assert FlowTask

zrb/action/runner.py

@@ -110,7 +110,12 @@ class Runner:
 
     def __get_wrapped_task_function(self, task: AnyTask) -> Callable[..., Any]:
         def wrapped_function(*args: Any, **kwargs: Any) -> Any:
-            function = task.to_function(env_prefix=self.__env_prefix, raise_error=True)
+            function = task.to_function(
+                env_prefix=self.__env_prefix,
+                raise_error=True,
+                should_clear_xcom=True,
+                should_stop_looper=True,
+            )
             try:
                 function(*args, **kwargs)
             except Exception:

zrb/builtin/_helper/reccuring_action.py

@@ -1,6 +1,4 @@
-from zrb.helper.typing import Any
 from zrb.task.cmd_task import CmdTask
-from zrb.task.decorator import python_task
 from zrb.task.notifier import Notifier
 from zrb.task.task import Task
 from zrb.task_input.str_input import StrInput
@@ -8,8 +6,6 @@ from zrb.task_input.str_input import StrInput
 
 def create_recurring_action(
     notif_title: str,
-    trigger_caption: str,
-    trigger_xcom_key: str,
     default_message: str = "👋",
 ) -> Task:
     # define inputs
@@ -23,16 +19,11 @@ def create_recurring_action(
         default="",
         prompt="Command to be executed",
     )
-    # define tasks
-    show_trigger_info = _create_show_trigger_info(
-        trigger_caption=trigger_caption, trigger_xcom_key=trigger_xcom_key
-    )
     run_command = CmdTask(
         name="run-command",
         icon="⚙️",
         color="blue",
         inputs=[command_input],
-        upstreams=[show_trigger_info],
         should_execute='{{ input.command != "" }}',
         cmd="{{ input.command }}",
     )
@@ -43,7 +34,6 @@ def create_recurring_action(
         inputs=[message_input],
         title=notif_title,
         message="{{ input.message }}",
-        upstreams=[show_trigger_info],
         should_execute='{{ input.message != "" }}',
     )
     # return aggregator task
@@ -53,16 +43,3 @@ def create_recurring_action(
         upstreams=[run_command, notify],
         retry=0,
     )
-
-
-def _create_show_trigger_info(trigger_caption: str, trigger_xcom_key: str) -> Task:
-    @python_task(
-        name="show-trigger-info",
-        icon="🔍",
-        color="magenta",
-    )
-    def show_trigger_info(*args: Any, **kwargs: Any):
-        task: Task = kwargs.get("_task")
-        task.print_out(f"{trigger_caption}: {task.get_xcom(trigger_xcom_key)}")
-
-    return show_trigger_info

zrb/builtin/devtool/install/helix/resource/config.toml

@@ -3,6 +3,7 @@ theme = "gruvbox_transparent"
 [editor]
 line-number = "relative"
 mouse = true
+bufferline = "always"
 
 [editor.cursor-shape]
 insert = "bar"
@@ -16,4 +17,4 @@ enable = true
 hidden = false
 git-ignore = false
 git-global = false
-git-exclude = false
+git-exclude = false

zrb/builtin/process/pid/get_by_name.py

@@ -16,7 +16,7 @@ get_process_pid_by_name = CmdTask(
             prompt="Process name to be checked",
         )
     ],
-    cmd="pgrep {{ input.name }}",
+    cmd='pgrep "{{ input.name }}" || exit 0',
     checking_interval=3,
 )
 runner.register(get_process_pid_by_name)

zrb/builtin/schedule.py

@@ -1,10 +1,10 @@
 from zrb.builtin._helper.reccuring_action import create_recurring_action
 from zrb.runner import runner
-from zrb.task.recurring_task import RecurringTask
+from zrb.task.server import Controller, Server
 from zrb.task.time_watcher import TimeWatcher
 from zrb.task_input.str_input import StrInput
 
-schedule = RecurringTask(
+schedule = Server(
     name="schedule",
     icon="📅",
     color="yellow",
@@ -17,15 +17,19 @@ schedule = RecurringTask(
             description="Schedule cron pattern to show the message",
         ),
     ],
-    triggers=[
-        TimeWatcher(
-            name="watch-time", color="cyan", icon="⏰", schedule="{{input.schedule}}"
+    controllers=[
+        Controller(
+            name="periodic",
+            trigger=TimeWatcher(
+                name="watch-time",
+                color="cyan",
+                icon="⏰",
+                schedule="{{input.schedule}}",
+            ),
+            action=create_recurring_action(
+                notif_title="Schedule",
+            ),
         )
     ],
-    task=create_recurring_action(
-        notif_title="Schedule",
-        trigger_caption="Schedule",
-        trigger_xcom_key="watch-time.scheduled-time",
-    ),
 )
 runner.register(schedule)

zrb/builtin/watch_changes.py

@@ -1,10 +1,10 @@
 from zrb.builtin._helper.reccuring_action import create_recurring_action
 from zrb.runner import runner
 from zrb.task.path_watcher import PathWatcher
-from zrb.task.recurring_task import RecurringTask
+from zrb.task.server import Controller, Server
 from zrb.task_input.str_input import StrInput
 
-watch_changes = RecurringTask(
+watch_changes = Server(
     name="watch-changes",
     icon="🕵️",
     color="yellow",
@@ -23,19 +23,20 @@ watch_changes = RecurringTask(
             description="Ignored file pattern",
         ),
     ],
-    triggers=[
-        PathWatcher(
-            name="watch-path",
-            color="cyan",
-            icon="👀",
-            path="{{input.pattern}}",
-            ignored_path="{{input.ignored_pattern}}",
+    controllers=[
+        Controller(
+            name="watch",
+            trigger=PathWatcher(
+                name="watch-path",
+                color="cyan",
+                icon="👀",
+                path="{{input.pattern}}",
+                ignored_path="{{input.ignored_pattern}}",
+            ),
+            action=create_recurring_action(
+                notif_title="Watch",
+            ),
         )
     ],
-    task=create_recurring_action(
-        notif_title="Watch",
-        trigger_caption="File changes",
-        trigger_xcom_key="watch-path.file",
-    ),
 )
 runner.register(watch_changes)

zrb/helper/callable.py

@@ -1,3 +1,4 @@
+import asyncio
 import inspect
 from typing import Any, Callable
 
@@ -10,4 +11,6 @@ logger.debug(colored("Loading zrb.helper.callable", attrs=["dark"]))
 async def run_async(fn: Callable, *args: Any, **kwargs: Any) -> Any:
     if inspect.iscoroutinefunction(fn):
         return await fn(*args, **kwargs)
-    return fn(*args, **kwargs)
+    coro = asyncio.to_thread(fn, *args, **kwargs)
+    task = asyncio.create_task(coro)
+    return await task

zrb/task/any_task.py

@@ -308,6 +308,7 @@ class AnyTask(ABC):
         is_async: bool = False,
         show_done_info: bool = True,
         should_clear_xcom: bool = False,
+        should_stop_looper: bool = False,
     ) -> Callable[..., Any]:
         """
         Converts the current task into a callable function.

zrb/task/base_task/base_task.py

@@ -26,6 +26,7 @@ from zrb.task.any_task_event_handler import (
 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.looper import looper
 from zrb.task.parallel import AnyParallel
 from zrb.task_env.env import Env, PrivateEnv
 from zrb.task_env.env_file import EnvFile
@@ -140,7 +141,7 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
         xcom_dir = self.__get_xcom_dir()
         xcom_file = os.path.join(xcom_dir, key)
         with open(xcom_file, "w") as f:
-            f.write(value)
+            f.write(f"{value}")
 
     def get_xcom(self, key: str) -> str:
         self.__ensure_xcom_dir_exists()
@@ -164,6 +165,7 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
         is_async: bool = False,
         show_done_info: bool = True,
         should_clear_xcom: bool = False,
+        should_stop_looper: bool = False,
     ) -> Callable[..., Any]:
         async def function(*args: Any, **kwargs: Any) -> Any:
             self.log_info("Copy task")
@@ -175,6 +177,8 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
                 kwargs=kwargs,
                 show_done_info=show_done_info,
             )
+            if should_stop_looper:
+                looper.stop()
             if should_clear_xcom:
                 self_cp.clear_xcom()
             return result

zrb/task/checker.py

@@ -83,15 +83,15 @@ class Checker(BaseTask):
         while True:
             self._should_show_progress = wait_time >= self._progress_interval
             inspect_result = await self.inspect(*args, **kwargs)
-            if inspect_result == self._expected_result:
+            if inspect_result is not None and inspect_result == self._expected_result:
                 return True
             if wait_time >= self._progress_interval:
                 wait_time = 0
             await asyncio.sleep(self._checking_interval)
             wait_time += self._checking_interval
 
-    async def inspect(self, *args: Any, **kwargs: Any) -> bool:
-        return False
+    async def inspect(self, *args: Any, **kwargs: Any) -> Optional[bool]:
+        return None
 
     def show_progress(self, message: str):
         if self._should_show_progress:

zrb/task/cmd_task.py

@@ -199,8 +199,17 @@ class CmdTask(BaseTask):
         raise_error: bool = True,
         is_async: bool = False,
         show_done_info: bool = True,
+        should_clear_xcom: bool = False,
+        should_stop_looper: bool = False,
     ) -> Callable[..., CmdResult]:
-        return super().to_function(env_prefix, raise_error, is_async, show_done_info)
+        return super().to_function(
+            env_prefix=env_prefix,
+            raise_error=raise_error,
+            is_async=is_async,
+            show_done_info=show_done_info,
+            should_clear_xcom=should_clear_xcom,
+            should_stop_looper=should_stop_looper,
+        )
 
     def print_result(self, result: CmdResult):
         if not self._should_print_cmd_result or result.output == "":

zrb/task/http_checker.py

@@ -133,8 +133,17 @@ class HTTPChecker(Checker):
         raise_error: bool = True,
         is_async: bool = False,
         show_done_info: bool = True,
+        should_clear_xcom: bool = False,
+        should_stop_looper: bool = False,
     ) -> Callable[..., bool]:
-        return super().to_function(env_prefix, raise_error, is_async, show_done_info)
+        return super().to_function(
+            env_prefix=env_prefix,
+            raise_error=raise_error,
+            is_async=is_async,
+            show_done_info=show_done_info,
+            should_clear_xcom=should_clear_xcom,
+            should_stop_looper=should_stop_looper,
+        )
 
     async def run(self, *args: Any, **kwargs: Any) -> bool:
         self._config = HttpConnectionConfig(

zrb/task/looper.py

@@ -0,0 +1,40 @@
+from zrb.helper.accessories.color import colored
+from zrb.helper.callable import run_async
+from zrb.helper.log import logger
+from zrb.helper.typing import Callable, List, Mapping, Optional
+
+logger.debug(colored("Loading zrb.task.looper", attrs=["dark"]))
+
+
+class Looper:
+    def __init__(self):
+        self._queue: Mapping[str, List[Optional[bool]]] = {}
+        self._should_stop = False
+
+    async def pop(self, identifier: str) -> Optional[bool]:
+        if identifier not in self._queue or len(self._queue[identifier]) == 0:
+            return None
+        return self._queue[identifier].pop(0)
+
+    def stop(self):
+        self._should_stop = True
+
+    def is_registered(self, identifier: str) -> bool:
+        return identifier in self._queue
+
+    async def register(self, identifier: str, function: Callable[..., Optional[bool]]):
+        if identifier in self._queue:
+            return
+        self._queue[identifier] = []
+        while not self._should_stop:
+            try:
+                result = await run_async(function)
+                if result is not None:
+                    if not result:
+                        continue
+                    self._queue[identifier].append(result)
+            except KeyboardInterrupt:
+                break
+
+
+looper = Looper()

zrb/task/path_checker.py

@@ -99,8 +99,17 @@ class PathChecker(Checker):
         raise_error: bool = True,
         is_async: bool = False,
         show_done_info: bool = True,
+        should_clear_xcom: bool = False,
+        should_stop_looper: bool = False,
     ) -> Callable[..., bool]:
-        return super().to_function(env_prefix, raise_error, is_async, show_done_info)
+        return super().to_function(
+            env_prefix=env_prefix,
+            raise_error=raise_error,
+            is_async=is_async,
+            show_done_info=show_done_info,
+            should_clear_xcom=should_clear_xcom,
+            should_stop_looper=should_stop_looper,
+        )
 
     async def run(self, *args: Any, **kwargs: Any) -> bool:
         self._rendered_path = self.render_str(self._path)

zrb/task/path_watcher.py

@@ -25,7 +25,7 @@ from zrb.task.any_task_event_handler import (
     OnTriggered,
     OnWaiting,
 )
-from zrb.task.checker import Checker
+from zrb.task.watcher import Watcher
 from zrb.task_env.env import Env
 from zrb.task_env.env_file import EnvFile
 from zrb.task_group.group import Group
@@ -37,7 +37,7 @@ TPathWatcher = TypeVar("TPathWatcher", bound="PathWatcher")
 
 
 @typechecked
-class PathWatcher(Checker):
+class PathWatcher(Watcher):
     """
     PathWatcher will wait for any changes specified on  path.
 
@@ -49,6 +49,8 @@ class PathWatcher(Checker):
     - <task-name>.deleted-file
     """
 
+    __init_times: Mapping[str, Mapping[str, float]] = {}
+
     def __init__(
         self,
         name: str = "watch-path",
@@ -77,7 +79,7 @@ class PathWatcher(Checker):
         watch_deleted_files: bool = True,
         should_execute: Union[bool, JinjaTemplate, Callable[..., bool]] = True,
     ):
-        Checker.__init__(
+        Watcher.__init__(
             self,
             name=name,
             group=group,
@@ -107,7 +109,6 @@ class PathWatcher(Checker):
         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:
         return super().copy()
@@ -118,8 +119,17 @@ class PathWatcher(Checker):
         raise_error: bool = True,
         is_async: bool = False,
         show_done_info: bool = True,
+        should_clear_xcom: bool = False,
+        should_stop_looper: bool = False,
     ) -> Callable[..., bool]:
-        return super().to_function(env_prefix, raise_error, is_async, show_done_info)
+        return super().to_function(
+            env_prefix=env_prefix,
+            raise_error=raise_error,
+            is_async=is_async,
+            show_done_info=show_done_info,
+            should_clear_xcom=should_clear_xcom,
+            should_stop_looper=should_stop_looper,
+        )
 
     async def run(self, *args: Any, **kwargs: Any) -> bool:
         self._rendered_path = self.render_str(self._path)
@@ -128,7 +138,9 @@ class PathWatcher(Checker):
             for ignored_path in self._get_rendered_ignored_paths()
             if ignored_path != ""
         ]
-        self._init_times = self._get_mod_times()
+        identifier = self.get_identifier()
+        if identifier not in self.__init_times:
+            self.__init_times[identifier] = self._get_mod_times()
         return await super().run(*args, **kwargs)
 
     def _get_rendered_ignored_paths(self) -> List[str]:
@@ -136,41 +148,49 @@ class PathWatcher(Checker):
             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 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 = {
-                file
-                for file, mod_time in mod_times.items()
-                if file in mod_times and self._init_times[file] != mod_time
-            }
-            for file in modified_files:
-                self.print_out_dark(f"{label} [/] File modified: {file}")
-                self.set_task_xcom("modified-file", file)
-                self.set_task_xcom("file", file)
-                return True
-        self.show_progress(f"{label} (Nothing changed)")
-        return False
+    def create_loop_inspector(self) -> Callable[..., Optional[bool]]:
+        def loop_inspect() -> bool:
+            label = f"Watching {self._rendered_path}"
+            identifier = self.get_identifier()
+            try:
+                init_times = self.__init_times[identifier]
+                mod_times = self._get_mod_times()
+            except Exception as e:
+                self.show_progress(f"{label} Cannot inspect")
+                raise e
+            # watch changes
+            if self._watch_new_files:
+                new_files = mod_times.keys() - init_times.keys()
+                for file in new_files:
+                    self.print_out_dark(f"{label} [+] New file detected: {file}")
+                    self.set_task_xcom("new-file", file)
+                    self.set_task_xcom("file", file)
+                    self.__init_times[identifier] = self._get_mod_times()
+                    return True
+            if self._watch_deleted_files:
+                deleted_files = init_times.keys() - mod_times.keys()
+                for file in deleted_files:
+                    self.print_out_dark(f"{label} [-] File deleted: {file}")
+                    self.set_task_xcom("deleted-file", file)
+                    self.set_task_xcom("file", file)
+                    self.__init_times[identifier] = self._get_mod_times()
+                    return True
+            if self._watch_modified_files:
+                modified_files = {
+                    file
+                    for file, mod_time in mod_times.items()
+                    if file in mod_times and init_times[file] != mod_time
+                }
+                for file in modified_files:
+                    self.print_out_dark(f"{label} [/] File modified: {file}")
+                    self.set_task_xcom("modified-file", file)
+                    self.set_task_xcom("file", file)
+                    self.__init_times[identifier] = self._get_mod_times()
+                    return True
+            self.show_progress(f"{label} (Nothing changed)")
+            return False
+
+        return loop_inspect
 
     def _get_mod_times(self) -> Mapping[str, float]:
         matches = get_file_names(

zrb/task/port_checker.py

@@ -109,8 +109,17 @@ class PortChecker(Checker):
         raise_error: bool = True,
         is_async: bool = False,
         show_done_info: bool = True,
+        should_clear_xcom: bool = False,
+        should_stop_looper: bool = False,
     ) -> Callable[..., bool]:
-        return super().to_function(env_prefix, raise_error, is_async, show_done_info)
+        return super().to_function(
+            env_prefix=env_prefix,
+            raise_error=raise_error,
+            is_async=is_async,
+            show_done_info=show_done_info,
+            should_clear_xcom=should_clear_xcom,
+            should_stop_looper=should_stop_looper,
+        )
 
     async def run(self, *args: Any, **kwargs: Any) -> bool:
         self._config = PortConfig(

zrb/task/recurring_task.py

@@ -115,6 +115,7 @@ class RecurringTask(BaseTask):
         self._triggers: List[AnyTask] = [trigger.copy() for trigger in triggers]
         self._run_configs: List[RunConfig] = []
         self._single_execution = single_execution
+        self.print_err("Deprecated, please use Server instead")
 
     async def _set_keyval(self, kwargs: Mapping[str, Any], env_prefix: str):
         await super()._set_keyval(kwargs=kwargs, env_prefix=env_prefix)

zrb/task/resource_maker.py

@@ -144,8 +144,17 @@ class ResourceMaker(BaseTask):
         raise_error: bool = True,
         is_async: bool = False,
         show_done_info: bool = True,
+        should_clear_xcom: bool = False,
+        should_stop_looper: bool = False,
     ) -> Callable[..., bool]:
-        return super().to_function(env_prefix, raise_error, is_async, show_done_info)
+        return super().to_function(
+            env_prefix=env_prefix,
+            raise_error=raise_error,
+            is_async=is_async,
+            show_done_info=show_done_info,
+            should_clear_xcom=should_clear_xcom,
+            should_stop_looper=should_stop_looper,
+        )
 
     async def run(self, *args: Any, **kwargs: Any) -> bool:
         # render parameters

zrb/task/server.py

@@ -0,0 +1,190 @@
+import asyncio
+
+from zrb.helper.accessories.color import colored
+from zrb.helper.accessories.name import get_random_name
+from zrb.helper.log import logger
+from zrb.helper.typecheck import typechecked
+from zrb.helper.typing import Any, Callable, Iterable, List, Mapping, Optional, Union
+from zrb.helper.util import to_kebab_case
+from zrb.task.any_task import AnyTask
+from zrb.task.any_task_event_handler import (
+    OnFailed,
+    OnReady,
+    OnRetry,
+    OnSkipped,
+    OnStarted,
+    OnTriggered,
+    OnWaiting,
+)
+from zrb.task.base_task.base_task import BaseTask
+from zrb.task.flow_task import FlowTask
+from zrb.task_env.env import Env
+from zrb.task_env.env_file import EnvFile
+from zrb.task_group.group import Group
+from zrb.task_input.any_input import AnyInput
+
+logger.debug(colored("Loading zrb.task.server", attrs=["dark"]))
+
+
+@typechecked
+class Controller:
+    def __init__(
+        self,
+        trigger: Union[AnyTask, List[AnyTask]],
+        action: Union[AnyTask, List[AnyTask]],
+        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._args: List[Any] = []
+        self._kwargs: Mapping[str, Any] = {}
+        self._inputs: List[AnyInput] = []
+        self._envs: List[Env] = []
+        self._env_files: List[EnvFile] = []
+
+    def set_args(self, args: List[Any]):
+        self._args = args
+
+    def set_kwargs(self, kwargs: Mapping[str, Any]):
+        self._kwargs = kwargs
+
+    def set_inputs(self, inputs: List[AnyInput]):
+        self._inputs = inputs
+
+    def set_envs(self, envs: List[Env]):
+        self._envs = envs
+
+    def set_env_files(self, env_files: List[EnvFile]):
+        self._env_files = env_files
+
+    def get_sub_env_files(self) -> Iterable[EnvFile]:
+        env_files = []
+        for trigger in self._triggers:
+            env_files += trigger.copy()._get_env_files()
+        for action in self._actions:
+            env_files += action.copy()._get_env_files()
+        return env_files
+
+    def get_sub_envs(self) -> Iterable[Env]:
+        envs = []
+        for trigger in self._triggers:
+            envs += trigger.copy()._get_envs()
+        for action in self._actions:
+            envs += action.copy()._get_envs()
+        return envs
+
+    def get_sub_inputs(self) -> Iterable[AnyInput]:
+        inputs = []
+        for trigger in self._triggers:
+            inputs += trigger.copy()._get_combined_inputs()
+        for action in self._actions:
+            inputs += action.copy()._get_combined_inputs()
+        return inputs
+
+    def to_function(self) -> Callable[..., Any]:
+        task = self._get_task()
+
+        async def fn() -> Any:
+            task_fn = task.to_function(is_async=True)
+            return await task_fn(*self._args, **self._kwargs)
+
+        return fn
+
+    def _get_task(self) -> AnyTask:
+        actions = [action.copy() for action in self._actions]
+        actions.insert(0, self._get_remonitor_task())
+        triggers = [trigger.copy() for trigger in self._triggers]
+        task: AnyTask = FlowTask(
+            name=to_kebab_case(self._name),
+            inputs=self._inputs,
+            envs=self._envs,
+            env_files=self._env_files,
+            steps=[triggers, actions],
+        )
+        return task
+
+    def _get_remonitor_task(self) -> AnyTask:
+        async def on_ready(task: AnyTask):
+            task = self._get_task()
+            fn = task.to_function(is_async=True)
+            await fn()
+
+        return BaseTask(
+            name=f"monitor-{to_kebab_case(self._name)}",
+            on_ready=on_ready,
+        )
+
+
+@typechecked
+class Server(BaseTask):
+
+    def __init__(
+        self,
+        name: str,
+        controllers: List[Controller],
+        group: Optional[Group] = None,
+        inputs: Iterable[AnyInput] = [],
+        envs: Iterable[Env] = [],
+        env_files: Iterable[EnvFile] = [],
+        icon: Optional[str] = None,
+        color: Optional[str] = None,
+        description: str = "",
+        upstreams: Iterable[AnyTask] = [],
+        fallbacks: Iterable[AnyTask] = [],
+        on_triggered: Optional[OnTriggered] = None,
+        on_waiting: Optional[OnWaiting] = None,
+        on_skipped: Optional[OnSkipped] = None,
+        on_started: Optional[OnStarted] = None,
+        on_ready: Optional[OnReady] = None,
+        on_retry: Optional[OnRetry] = None,
+        on_failed: Optional[OnFailed] = None,
+        checkers: Iterable[AnyTask] = [],
+        checking_interval: float = 0,
+        retry: int = 0,
+        retry_interval: 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()
+        BaseTask.__init__(
+            self,
+            name=name,
+            group=group,
+            inputs=inputs,
+            envs=envs,
+            env_files=env_files,
+            icon=icon,
+            color=color,
+            description=description,
+            upstreams=upstreams,
+            fallbacks=fallbacks,
+            on_triggered=on_triggered,
+            on_waiting=on_waiting,
+            on_skipped=on_skipped,
+            on_started=on_started,
+            on_ready=on_ready,
+            on_retry=on_retry,
+            on_failed=on_failed,
+            checkers=checkers,
+            checking_interval=checking_interval,
+            retry=retry,
+            retry_interval=retry_interval,
+            should_execute=should_execute,
+            return_upstream_result=return_upstream_result,
+        )
+        self._controllers = controllers
+
+    async def run(self, *args: Any, **kwargs: Any):
+        for controller in self._controllers:
+            controller.set_envs(self._get_envs())
+            controller.set_env_files(self._get_env_files())
+            controller.set_inputs(self._get_inputs())
+            controller.set_args(args)
+            controller.set_kwargs(kwargs)
+        functions = [controller.to_function() for controller in self._controllers]
+        await asyncio.gather(*[fn() for fn in functions])

zrb/task/time_watcher.py

@@ -1,3 +1,4 @@
+import asyncio
 import datetime
 
 import croniter
@@ -10,6 +11,7 @@ from zrb.helper.typing import (
     Callable,
     Iterable,
     JinjaTemplate,
+    Mapping,
     Optional,
     TypeVar,
     Union,
@@ -24,7 +26,7 @@ from zrb.task.any_task_event_handler import (
     OnTriggered,
     OnWaiting,
 )
-from zrb.task.checker import Checker
+from zrb.task.watcher import Watcher
 from zrb.task_env.env import Env
 from zrb.task_env.env_file import EnvFile
 from zrb.task_group.group import Group
@@ -36,7 +38,7 @@ TTimeWatcher = TypeVar("TTimeWatcher", bound="TimeWatcher")
 
 
 @typechecked
-class TimeWatcher(Checker):
+class TimeWatcher(Watcher):
     """
     TimeWatcher will wait for any changes specified on  path.
 
@@ -44,6 +46,8 @@ class TimeWatcher(Checker):
     and <task-name>.scheduled-time xcom will be set.
     """
 
+    __scheduled_times: Mapping[str, Mapping[str, datetime.datetime]] = {}
+
     def __init__(
         self,
         name: str = "watch-path",
@@ -68,7 +72,7 @@ class TimeWatcher(Checker):
         progress_interval: Union[int, float] = 30,
         should_execute: Union[bool, JinjaTemplate, Callable[..., bool]] = True,
     ):
-        Checker.__init__(
+        Watcher.__init__(
             self,
             name=name,
             group=group,
@@ -92,7 +96,6 @@ class TimeWatcher(Checker):
             should_execute=should_execute,
         )
         self._schedule = schedule
-        self._scheduled_time: Optional[datetime.datetime] = None
         self._rendered_schedule: str = ""
 
     def copy(self) -> TTimeWatcher:
@@ -104,23 +107,48 @@ class TimeWatcher(Checker):
         raise_error: bool = True,
         is_async: bool = False,
         show_done_info: bool = True,
+        should_clear_xcom: bool = False,
+        should_stop_looper: bool = False,
     ) -> Callable[..., bool]:
-        return super().to_function(env_prefix, raise_error, is_async, show_done_info)
+        return super().to_function(
+            env_prefix=env_prefix,
+            raise_error=raise_error,
+            is_async=is_async,
+            show_done_info=show_done_info,
+            should_clear_xcom=should_clear_xcom,
+            should_stop_looper=should_stop_looper,
+        )
 
     async def run(self, *args: Any, **kwargs: Any) -> bool:
         self._rendered_schedule = self.render_str(self._schedule)
-        margin = datetime.timedelta(seconds=0.001)
-        slightly_before_check_time = datetime.datetime.now() - margin
-        cron = croniter.croniter(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)
+        identifier = self.get_identifier()
+        if identifier not in self.__scheduled_times:
+            self.__scheduled_times[identifier] = self._get_next_schedule_time()
         return await super().run(*args, **kwargs)
 
-    async def inspect(self, *args: Any, **kwargs: Any) -> bool:
-        label = f"Watching {self._rendered_schedule}"
-        now = datetime.datetime.now()
-        if now > self._scheduled_time:
-            self.print_out_dark(f"{label} (Meet {self._scheduled_time})")
-            return True
-        self.show_progress(f"{label} (Waiting for {self._scheduled_time})")
-        return False
+    def create_loop_inspector(self) -> Callable[..., Optional[bool]]:
+        async def loop_inspect() -> bool:
+            await asyncio.sleep(0.1)
+            label = f"Watching {self._rendered_schedule}"
+            identifier = self.get_identifier()
+            scheduled_time = self.__scheduled_times[identifier]
+            self.set_task_xcom(key="scheduled-time", value=scheduled_time)
+            now = datetime.datetime.now()
+            if now > scheduled_time:
+                self.print_out_dark(f"{label} (Meet {scheduled_time})")
+                self.__scheduled_times[identifier] = self._get_next_schedule_time()
+                return True
+            self.show_progress(f"{label} (Waiting for {scheduled_time})")
+            return False
+
+        return loop_inspect
+
+    def _get_next_schedule_time(self) -> datetime.datetime:
+        cron = self._get_cron()
+        return cron.get_next(datetime.datetime)
+
+    def _get_cron(self) -> Any:
+        margin = datetime.timedelta(seconds=0.001)
+        slightly_before_now = datetime.datetime.now() - margin
+        cron = croniter.croniter(self._rendered_schedule, slightly_before_now)
+        return cron

zrb/task/watcher.py

@@ -0,0 +1,100 @@
+import asyncio
+
+from zrb.helper.accessories.color import colored
+from zrb.helper.accessories.name import get_random_name
+from zrb.helper.log import logger
+from zrb.helper.typecheck import typechecked
+from zrb.helper.typing import Any, Callable, Iterable, Optional, Union
+from zrb.task.any_task import AnyTask
+from zrb.task.any_task_event_handler import (
+    OnFailed,
+    OnReady,
+    OnRetry,
+    OnSkipped,
+    OnStarted,
+    OnTriggered,
+    OnWaiting,
+)
+from zrb.task.checker import Checker
+from zrb.task.looper import looper
+from zrb.task_env.env import Env
+from zrb.task_env.env_file import EnvFile
+from zrb.task_group.group import Group
+from zrb.task_input.any_input import AnyInput
+
+logger.debug(colored("Loading zrb.task.watcher", attrs=["dark"]))
+
+
+@typechecked
+class Watcher(Checker):
+    __looper = looper
+
+    def __init__(
+        self,
+        name: str = "watch",
+        group: Optional[Group] = None,
+        inputs: Iterable[AnyInput] = [],
+        envs: Iterable[Env] = [],
+        env_files: Iterable[EnvFile] = [],
+        icon: Optional[str] = None,
+        color: Optional[str] = None,
+        description: str = "",
+        upstreams: Iterable[AnyTask] = [],
+        fallbacks: Iterable[AnyTask] = [],
+        on_triggered: Optional[OnTriggered] = None,
+        on_waiting: Optional[OnWaiting] = None,
+        on_skipped: Optional[OnSkipped] = None,
+        on_started: Optional[OnStarted] = None,
+        on_ready: Optional[OnReady] = None,
+        on_retry: Optional[OnRetry] = None,
+        on_failed: Optional[OnFailed] = None,
+        checking_interval: Union[int, float] = 0.1,
+        progress_interval: Union[int, float] = 30,
+        expected_result: bool = True,
+        should_execute: Union[bool, str, Callable[..., bool]] = True,
+    ):
+        Checker.__init__(
+            self,
+            name=name,
+            group=group,
+            inputs=inputs,
+            envs=envs,
+            env_files=env_files,
+            icon=icon,
+            color=color,
+            description=description,
+            upstreams=upstreams,
+            fallbacks=fallbacks,
+            on_triggered=on_triggered,
+            on_waiting=on_waiting,
+            on_skipped=on_skipped,
+            on_started=on_started,
+            on_ready=on_ready,
+            on_retry=on_retry,
+            on_failed=on_failed,
+            checking_interval=checking_interval,
+            should_execute=should_execute,
+            progress_interval=progress_interval,
+            expected_result=expected_result,
+        )
+        self._identifier = get_random_name()
+
+    def get_identifier(self):
+        return self._identifier
+
+    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())
+            )
+        return await super().run(*args, **kwargs)
+
+    async def inspect(self, *args, **kwargs: Any) -> Optional[bool]:
+        result = await looper.pop(self._identifier)
+        return result
+
+    def create_loop_inspector(self) -> Callable[..., Optional[bool]]:
+        def loop_inspect() -> Optional[bool]:
+            return None
+
+        return loop_inspect

{zrb-0.15.1.dist-info → zrb-0.17.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zrb
-Version: 0.15.1
+Version: 0.17.0
 Summary: A Framework to Enhance Your Workflow
 Home-page: https://github.com/state-alchemists/zrb
 License: AGPL-3.0-or-later

{zrb-0.15.1.dist-info → zrb-0.17.0.dist-info}/RECORD

@@ -1,11 +1,11 @@
-zrb/__init__.py,sha256=QNtBHrQnz4dEnnFtgrUBUUl9Ph7cUVFt6zJe3PpN0d0,2683
+zrb/__init__.py,sha256=KH6bpJxEldzDMn-39IdUxEs9Ir5qUeqW_iC56iQKPMk,2814
 zrb/__main__.py,sha256=-_k0XOahDF-06n41Uly-oUMkZ8XDSxO-WUUImWz6GiA,171
 zrb/action/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-zrb/action/runner.py,sha256=Z_Rh60DA0U_HqO4t_NzWTmXvHVfdgaL5RQJfTnEZiFQ,4951
+zrb/action/runner.py,sha256=oizUiLa4wa4CjXppbw_YUFlkAUSwapfoQ1YAo9TEY30,5079
 zrb/advertisement.py,sha256=eqdQvr2IDS2ZTiOhg2R12wq0A5tnaoPATaH5nd1xfC8,699
 zrb/builtin/__init__.py,sha256=QrJY08zBC55xkJa_kNhGAWEnhHwATZbNGxEEXEn-Ywk,3247
 zrb/builtin/_helper/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-zrb/builtin/_helper/reccuring_action.py,sha256=_oApvOrn7K4NZa-vt-A-xvpUSPjPEG2gydPXzJEUzSo,1940
+zrb/builtin/_helper/reccuring_action.py,sha256=3YeMtGM13iwSV8kMJ64wuGDwAgKB7KD2nuaqKXuMRPw,1186
 zrb/builtin/base64/__init__.py,sha256=Dl5eG_I7xvigiEp4mURXoF8J78Y2UixaDmI1O74bsrY,218
 zrb/builtin/base64/_group.py,sha256=4aDDjvtoZUpXBst4TPDxsJvXhlefvQjUaSOteyJP83w,109
 zrb/builtin/base64/_input.py,sha256=dQA-svhwA7qrtGRpe2jYjVuwvQxxyq9MKIR-e1ay8ks,128
@@ -30,7 +30,7 @@ zrb/builtin/devtool/install/gvm/resource/config.sh,sha256=M_r6XjtoYZjx8rJaT3FIwV
 zrb/builtin/devtool/install/helix/helix.py,sha256=W0Xm_eq0wIHcoq0CzG9WrQIH9tPByT-AZ-zi4Z72-U0,2098
 zrb/builtin/devtool/install/helix/install-language-server.sh,sha256=ZkV_ARwhTnLjjbAhJe8Pvp1hyRYVn176DYwg7ObkQ1w,1040
 zrb/builtin/devtool/install/helix/install.sh,sha256=Dsg65aEnpU8YnlvHwiKoxRpj8Jo8j3mejB4bTi2eeKo,1375
-zrb/builtin/devtool/install/helix/resource/config.toml,sha256=zEeA-oiVbCGs6dQNZAbeFfMJ3giClOkuhgJ6Pcel2ww,282
+zrb/builtin/devtool/install/helix/resource/config.toml,sha256=35IwzDzXGfSnUH3O3nyd2IzDVOWyKqj6Kb3QuympXCE,305
 zrb/builtin/devtool/install/helix/resource/themes/gruvbox_transparent.toml,sha256=Kz6AhxXKVHrP5mpFI99uPFyfUOvB_0x2fapj0tUkIaA,56
 zrb/builtin/devtool/install/helm/helm.py,sha256=Y2Iklrcw4-OQYNIjeuKmuIzpdAqGGcl82ZSHMFWck_E,762
 zrb/builtin/devtool/install/helm/install.sh,sha256=fqjaTsO25B2MV7134sriSY5hQ2A1VRsaLc3WmD5jKu4,228
@@ -90,7 +90,7 @@ zrb/builtin/process/__init__.py,sha256=dWM1zIehY65rkJvEAFvX6HGJHL8kb1gkzaSz0Woay
 zrb/builtin/process/_group.py,sha256=KY7iQ_pvqe5iVsRFeLWs-O-xuSyqlTXVj47_TCnu7zQ,118
 zrb/builtin/process/pid/__init__.py,sha256=Rcb3bYgR_oVNOlaggYjcRipHRehrumZuQyadrguXdR0,293
 zrb/builtin/process/pid/_group.py,sha256=SUe7G8tmfg_Q-X3nHOqCUMjDXlTE_hb9gAKVie2wQ2A,195
-zrb/builtin/process/pid/get_by_name.py,sha256=fjJw0n353lhhyR1wnPHLXV13M9aNQmIAeQ_jUmBMVsA,625
+zrb/builtin/process/pid/get_by_name.py,sha256=cW4c9l4JUGa9w5VHUFWi_3tUyx55t7-6i12Gm_hCkhQ,637
 zrb/builtin/process/pid/get_by_port.py,sha256=_yz0jBAV7qIo-eU33peDgVhtzYhMAxAHOc6xQtDwXyc,640
 zrb/builtin/project/__init__.py,sha256=i1YF08_6UjNznYeL0iGTbU8o5yz7iw41RYd8UgeB8U4,887
 zrb/builtin/project/_group.py,sha256=RPWt2YOLIqF7ZznzkSeFm9dozz1oCKmpCWCA1jjgsl4,112
@@ -1280,7 +1280,7 @@ zrb/builtin/project/create/template/src/.gitkeep,sha256=47DEQpj8HBSa-_TImW-5JCeu
 zrb/builtin/project/create/template/template.env,sha256=Y_11yIi7fA5aIOHxrcexFXNxz1UqXaEiIgqUHBazy0w,102
 zrb/builtin/project/create/template/zrb_init.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/builtin/say.py,sha256=KHuzgwitmWQy5g7N11qqs9iV-66vvAl0Uyke9hdc-Eg,3859
-zrb/builtin/schedule.py,sha256=-yOfTAx4lORR7_4PCBpOwn8m-imN7oHs4-RTUL2DC-Y,990
+zrb/builtin/schedule.py,sha256=yzprSE8oPgtXssK1sW3YpaqhTHcECTQWnuuIweEqBNw,1048
 zrb/builtin/ubuntu/__init__.py,sha256=79JyTzx6pyhtEa7hrsUTNaAQ7xlrgDX1KU74OG8mhic,486
 zrb/builtin/ubuntu/_group.py,sha256=6VhCi-wZRuwvmELlvqvVSOfYLnibP8SQIT2GpaDPtOA,115
 zrb/builtin/ubuntu/install/__init__.py,sha256=AoGq7pPn8FWoRXrEwiaX1ZBBQTzFpqIjpwIx4aajpa8,472
@@ -1292,7 +1292,7 @@ zrb/builtin/ubuntu/install/toys.py,sha256=VlWb8_aHW1kRK6vpjpAveNByc1FlsMPLFXl1X9
 zrb/builtin/ubuntu/update.py,sha256=m3UREE6DhwlbdkQpuug2sfEM6fBLZn0ZGClt_EOsZ_I,372
 zrb/builtin/update.py,sha256=89i_fPUlL27IXczLI7Lr7k4STMpnxyw2je8daCKUTQo,225
 zrb/builtin/version.py,sha256=vjbmSeOSEjT0SgdeQHGslwFCQMukwVZkOOkusZGZNcU,394
-zrb/builtin/watch_changes.py,sha256=5oe1zPRamo5ZsWQKvgVWCXiBv4encS4kN7mubgvacjk,1192
+zrb/builtin/watch_changes.py,sha256=Vr__e_T31nnbefcPftvyn78dT3-UXqNRpH0KO-COeKQ,1220
 zrb/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/config/config.py,sha256=6uDxOLmHHstLCosj2miBVxlO9dMTIoXYedqaff8EVBU,1567
 zrb/helper/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -1302,7 +1302,7 @@ zrb/helper/accessories/icon.py,sha256=uKm3w5G1fV454MUhz_CZMy48AD99kBV9j2zRlJWzB1
 zrb/helper/accessories/name.py,sha256=e1uvU3MzuvDb5j6YIWBA048y4qeM-LfrxRKWlMehliE,1638
 zrb/helper/accessories/untyped_color.py,sha256=4wRbHSClbCzPRWtW-Cy2agOMozANVi7u4p8lMXMSuJg,194
 zrb/helper/advertisement.py,sha256=-J9xVxf6AmcB0Uy-D4tFl-IRIZsdKTy07wIoE59jMnc,896
-zrb/helper/callable.py,sha256=iRL-qVNjSYbiwxM9RRjh0hn0z0s1eS22mkZA4xWRuhg,385
+zrb/helper/callable.py,sha256=G_seq9gAricPjzlUdZs2rswQEt8sfnKQo1EFKi9JYyQ,478
 zrb/helper/cli.py,sha256=Ux0zkKYahrM_aVQkkuPxfOuMNmTrCIWxdOIgNJvu5OY,2177
 zrb/helper/codemod/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/helper/codemod/add_argument_to_function.py,sha256=Xh5Tlb4iO3cv4dRR12ms9kf0j-atVSnCh88TuqCof8I,1435
@@ -1355,34 +1355,37 @@ zrb/shell-scripts/notify.ps1,sha256=6_xPoIwuxARpYljcjVV-iRJS3gJqGfx-B6kj719cJ9o,
 zrb/shell-scripts/rsync-util.sh,sha256=QzdhSBvUNMxB4U2B4m0Dxg9czGckRjB7Vk4A1ObG0-k,353
 zrb/shell-scripts/ssh-util.sh,sha256=9lXDzw6oO8HuA4vdbfps_uQMMwKyNYX9fZkZgpK52g8,401
 zrb/task/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-zrb/task/any_task.py,sha256=WHsEUfWjRvvDqF0fxHh4_q2LmdJcnfVC9y0HFleiBZ0,39393
+zrb/task/any_task.py,sha256=1jc0qVZs1yIMfGuInktgH7EqDbI8IqmsaSlH5VijThc,39435
 zrb/task/any_task_event_handler.py,sha256=AjTC6lIcprutRusNBGl83EifQe4TbZzxdlVIR4ndWN4,524
 zrb/task/base_remote_cmd_task.py,sha256=tZi3jODMXfTkDAmWiFR2YdA-b4-TDTP1uLtO0ulmM34,10101
 zrb/task/base_task/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-zrb/task/base_task/base_task.py,sha256=UNaMB9fBz3NqBKDr59ayAUPnUr6cNOhXUdePJcZjcko,20207
+zrb/task/base_task/base_task.py,sha256=qnQSG-nAppmm38JY11wC03-0mZSOjjk-XJ62leco2rw,20354
 zrb/task/base_task/component/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/task/base_task/component/base_task_model.py,sha256=YlEuvYSzlrK83Kds07bu2drKSw3rKyl7qIR1qwIPNZk,10376
 zrb/task/base_task/component/common_task_model.py,sha256=JoAAf8EvuPx31fCK_TBxX_TBeHZrZyFDjLeK8ts0w3A,12285
 zrb/task/base_task/component/pid_model.py,sha256=RjJIqOpavucDssnd3q3gT4q8QnP8I9SUdlv1b9pR7kU,292
 zrb/task/base_task/component/renderer.py,sha256=9wP2IW811Ta81IoPWmeQ7yVc7eG-uaSnOVbEyeaOIuk,4439
 zrb/task/base_task/component/trackers.py,sha256=gM9eOukMh6kvNJnRsHscQ_JN--Haa2YA4bIufqh8upE,1950
-zrb/task/checker.py,sha256=dA_AitSmOmvqSl_ZRffeUNGfMRHRXokRH5Ti_94hZ0o,3343
-zrb/task/cmd_task.py,sha256=OamHPXW-lLBHPTOwgnSyLQ3UBvz4iuTVVm_5S6kgcqA,13892
+zrb/task/checker.py,sha256=fn6gmcCUHsar458NQ4Af4-kt2skcyibd0ewsPTRd5-w,3383
+zrb/task/cmd_task.py,sha256=_wjF9MbKGA0EAr_df47AMC0lROCiaJTUyxT-AFQKKJo,14181
 zrb/task/decorator.py,sha256=j62l7ITIRZtk_qE97d4naVl9gbbMoi2eEXOPOmYdF8M,3039
 zrb/task/docker_compose_task.py,sha256=fnFEOAS9yEi2ve7pSzN9guXOVeYt8HYTdQvtjk-yoRQ,14886
 zrb/task/flow_task.py,sha256=QIIZgq9C7e-kvTRJ0Y1Slb5AQyy15N9H4NZxdFR3FI8,4867
-zrb/task/http_checker.py,sha256=0DvfE6mTyBMZQYc4iX9woYm6Ip1CX-7P167Tpci-yD8,5403
+zrb/task/http_checker.py,sha256=DRIwXjC8StucHo2nP1duM3Ime3zzw1BQH8ib2bFZVmA,5692
+zrb/task/looper.py,sha256=aU7hwXLlfZRhH4rlusIwsusz5fHEhaYfwEpRUVcHx4o,1284
 zrb/task/notifier.py,sha256=19E4EcFgFZ0thU9p2P1dGUYR04721pa0K3lqsj6a4Xc,6217
 zrb/task/parallel.py,sha256=-coMuiFlS29GpBgW6plPVaCLesgzzD0bYib29OvhXFg,1193
-zrb/task/path_checker.py,sha256=65GpplGing3QeBPDtc1A_-PWXXiNItCXqabMLcgzm6s,4384
-zrb/task/path_watcher.py,sha256=UR-XMEB-Kly76T4QgGZSTeLxCk_sIiNi__Pm8FfO-yA,6499
-zrb/task/port_checker.py,sha256=uvOJPQqcZ_YQ1TTOxTfgfSc-7rAnSCWTYTgnY-eG4HY,4303
-zrb/task/recurring_task.py,sha256=q9vzZP3iFpHWEnQ2nJAdoAu15ZQothilZQ-ID16bUV8,7366
+zrb/task/path_checker.py,sha256=yvMgGlmMQhlaX3Wlq5yI7-nzEpyCFoXHEOFOdlfI6-o,4673
+zrb/task/path_watcher.py,sha256=UGaGYzWExoVQDK6smXEKsd0leO3FZOQYHnpHgZ9hiZU,7420
+zrb/task/port_checker.py,sha256=IoVIP0QjxKz2SLgnK2GIaxn4WASk6ZKf4cQlKog0Fw8,4592
+zrb/task/recurring_task.py,sha256=FNxV7n4h9AzUCU8oKXwAS_A9j1newS-esWjmMsC33vE,7430
 zrb/task/remote_cmd_task.py,sha256=rmLB5uCcbbfZBy8-nAZI8mgnNd-J2d4SBemLEDwSlV4,3951
-zrb/task/resource_maker.py,sha256=vY55cBCJMYQzkVKygkb6aNTJT6kfSjPunJqHKGA2N2Y,7355
+zrb/task/resource_maker.py,sha256=jQSO7PVIuTZi__JcrpRC4Ni_xmuJszJiMAxH_qfJPhs,7644
 zrb/task/rsync_task.py,sha256=bgCeZQTG-4isvjZGGs_05oOEkkwGc930NTyuUYUm_cg,4187
+zrb/task/server.py,sha256=CdzBkdWZvX1PTvloDrOXtCbAbMeK4KK75C33N_Wz3Sc,6408
 zrb/task/task.py,sha256=dHv4cmnd0QFPT9PwrfmHpxTaXj86mm8xf7_jAj_engI,329
-zrb/task/time_watcher.py,sha256=c5IPxUs4b5BsgGqyvjRVpeqXFJCHgCV-ke6uIvZ-_7A,4139
+zrb/task/time_watcher.py,sha256=xx82w8ygpL-6pUbeuWjsxSVLSZhkWVWHsAoZUXPV7Jk,5075
+zrb/task/watcher.py,sha256=m72YhUKtQsE4mZSm1y2MKiSdfj6HZo3rj9f3nQLU7Oo,3252
 zrb/task/wiki_task.py,sha256=Mcugk_6Pd7pzubi2ZP4eegJs8e9niYKh-9mCrNHXE_g,4330
 zrb/task_env/constant.py,sha256=ySdHv2dawWE-UoeBHl8FEOmrBl4vfkRI67TIBdkK6l8,220
 zrb/task_env/env.py,sha256=C9IzavEtWlpap4C92XONi1ID-RK9gDDLQKl5rYGBsyc,5195
@@ -1400,8 +1403,8 @@ zrb/task_input/int_input.py,sha256=d2fXcm5fCo09472eMAm6PdzLQD82ZBV9ARq5CjKepAo,4
 zrb/task_input/password_input.py,sha256=g_g8ZWAzDaHx4h2EHY3UCGvTigC6esAUBzXU0T9nDUk,4192
 zrb/task_input/str_input.py,sha256=BNflOhrJvST9bWK0rGdCi7C7y-QDvHj9ISQMRmujIWU,4200
 zrb/task_input/task_input.py,sha256=x1sGHsoSYAYMdQBrCLmcvZa_ZmGggMPj3goAQzewUKI,2181
-zrb-0.15.1.dist-info/LICENSE,sha256=WfnGCl8G60EYOPAEkuc8C9m9pdXWDe08NsKj3TBbxsM,728
-zrb-0.15.1.dist-info/METADATA,sha256=izpcqCCdrTuJBe7HKKxyMVeKZX9X2rc58JohKVaV228,16460
-zrb-0.15.1.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-zrb-0.15.1.dist-info/entry_points.txt,sha256=xTgXc1kBKYhJHEujdaSPHUcJT3-hbyP1mLgwkv-5sSk,40
-zrb-0.15.1.dist-info/RECORD,,
+zrb-0.17.0.dist-info/LICENSE,sha256=WfnGCl8G60EYOPAEkuc8C9m9pdXWDe08NsKj3TBbxsM,728
+zrb-0.17.0.dist-info/METADATA,sha256=GEA_jDoWaQ2X5kQMiLZFHMRqnYczd1HK-S5g8QwPYfI,16460
+zrb-0.17.0.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+zrb-0.17.0.dist-info/entry_points.txt,sha256=xTgXc1kBKYhJHEujdaSPHUcJT3-hbyP1mLgwkv-5sSk,40
+zrb-0.17.0.dist-info/RECORD,,