zrb 0.15.1__py3-none-any.whl → 0.17.2__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/helix.py

@@ -29,7 +29,6 @@ install_helix = FlowTask(
                 run=write_config(
                     template_file=os.path.join(
                         _CURRENT_DIR,
-                        "helix",
                         "resource",
                         "themes",
                         "gruvbox_transparent.toml",  # noqa
@@ -41,9 +40,7 @@ install_helix = FlowTask(
             Task(
                 name="configure-helix",
                 run=write_config(
-                    template_file=os.path.join(
-                        _CURRENT_DIR, "helix", "resource", "config.toml"
-                    ),
+                    template_file=os.path.join(_CURRENT_DIR, "resource", "config.toml"),
                     config_file="~/.config/helix/config.toml",
                     remove_old_config=True,
                 ),

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

@@ -25,14 +25,12 @@ TAnyTask = TypeVar("TAnyTask", bound="AnyTask")
 
 class AnyTask(ABC):
     """
-    Abstract base class for defining tasks in a task management system.
+    Contract/interface for all Zrb Task.
 
-    This class acts as a template for creating new task types. To define a new task,
-    extend this class and implement all its abstract methods. The `AnyTask` class is
-    considered atomic and is not broken into multiple interfaces.
+    This class acts as a template for creating new Zrb Task types.
 
-    Subclasses should implement the abstract methods to define custom behavior for
-    task execution, state transitions, and other functionalities.
+    To define a new Zrb Task, you should extend this class and implement all its methods.
+    The easiest way to do so is by extending `Task`
     """
 
     @abstractmethod
@@ -74,7 +72,7 @@ class AnyTask(ABC):
         Examples:
             >>> from zrb import Task
             >>> class MyTask(Task):
-            >>>     async def run(self, *args: Any, **kwargs: Any) -> int:
+            >>>     def run(self, *args: Any, **kwargs: Any) -> int:
             >>>         self.print_out('Doing some calculation')
             >>>         return 42
         """
@@ -88,8 +86,7 @@ class AnyTask(ABC):
         Any other tasks depends on the current task, will be `started` once the current task is `ready`.
 
         This method should be implemented to define the criteria for considering the task
-        `ready`. The specifics of this completion depend on the task's
-        nature and the subclass implementation.
+        `ready`. The specifics of this completion depend on the task's nature and the subclass implementation.
 
         Returns:
             bool: True if the task is completed, False otherwise.
@@ -308,6 +305,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
@@ -71,10 +72,10 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
     ):
         # init properties
         retry_interval = retry_interval if retry_interval >= 0 else 0
-        checking_interval = checking_interval if checking_interval > 0 else 0.1
+        checking_interval = checking_interval if checking_interval > 0 else 0.05
         retry = retry if retry >= 0 else 0
         # init parent classes
-        FinishTracker.__init__(self)
+        FinishTracker.__init__(self, checking_interval=checking_interval)
         Renderer.__init__(self)
         AttemptTracker.__init__(self, retry=retry)
         BaseTaskModel.__init__(
@@ -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
@@ -229,7 +233,7 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
             await run_async(self._on_retry, self)
 
     async def check(self) -> bool:
-        return await self._is_done()
+        return await run_async(self._is_done)
 
     def inject_envs(self):
         super().inject_envs()
@@ -311,7 +315,7 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
         if self.__is_check_triggered:
             self.log_debug("Waiting readiness flag to be set")
             while not self.__is_ready:
-                await asyncio.sleep(0.1)
+                await asyncio.sleep(self._checking_interval)
             return True
         self.__is_check_triggered = True
         check_result = await self._check()
@@ -332,7 +336,7 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
         self.log_debug("Waiting execution to be started")
         while not self.__is_execution_started:
             # Don't start checking before the execution itself has been started
-            await asyncio.sleep(0.05)
+            await asyncio.sleep(self._checking_interval / 2.0)
         check_coroutines: Iterable[asyncio.Task] = []
         for checker_task in self._get_checkers():
             checker_task._set_execution_id(self.get_execution_id())

zrb/task/base_task/component/trackers.py

@@ -2,7 +2,7 @@ import asyncio
 import time
 
 from zrb.helper.typecheck import typechecked
-from zrb.helper.typing import Optional
+from zrb.helper.typing import Optional, Union
 
 LOG_NAME_LENGTH = 20
 
@@ -51,9 +51,10 @@ class AttemptTracker:
 
 @typechecked
 class FinishTracker:
-    def __init__(self):
+    def __init__(self, checking_interval: Union[float, int]):
         self.__execution_queue: Optional[asyncio.Queue] = None
         self.__counter = 0
+        self.__checking_interval = checking_interval
 
     async def _mark_awaited(self):
         if self.__execution_queue is None:
@@ -69,5 +70,5 @@ class FinishTracker:
 
     async def _is_done(self) -> bool:
         while self.__execution_queue is None:
-            await asyncio.sleep(0.05)
+            await asyncio.sleep(self.__checking_interval / 2.0)
         return await self.__execution_queue.get()

zrb/task/checker.py

@@ -44,7 +44,7 @@ class Checker(BaseTask):
         on_ready: Optional[OnReady] = None,
         on_retry: Optional[OnRetry] = None,
         on_failed: Optional[OnFailed] = None,
-        checking_interval: Union[int, float] = 0.1,
+        checking_interval: Union[int, float] = 0,
         progress_interval: Union[int, float] = 30,
         expected_result: bool = True,
         should_execute: Union[bool, str, Callable[..., bool]] = True,
@@ -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/decorator.py

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

zrb/task/docker_compose_task.py

@@ -115,9 +115,9 @@ class DockerComposeTask(CmdTask):
         on_retry: Optional[OnRetry] = None,
         on_failed: Optional[OnFailed] = None,
         checkers: Iterable[AnyTask] = [],
-        checking_interval: float = 0.1,
+        checking_interval: Union[float, int] = 0,
         retry: int = 2,
-        retry_interval: float = 1,
+        retry_interval: Union[float, int] = 1,
         max_output_line: int = 1000,
         max_error_line: int = 1000,
         preexec_fn: Optional[Callable[[], Any]] = os.setsid,

zrb/task/http_checker.py

@@ -87,7 +87,7 @@ class HTTPChecker(Checker):
         on_ready: Optional[OnReady] = None,
         on_retry: Optional[OnRetry] = None,
         on_failed: Optional[OnFailed] = None,
-        checking_interval: Union[int, float] = 0.1,
+        checking_interval: Union[int, float] = 0,
         progress_interval: Union[int, float] = 5,
         expected_result: bool = True,
         should_execute: Union[bool, JinjaTemplate, Callable[..., bool]] = True,
@@ -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,43 @@
+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
+                    while len(self._queue[identifier]) > 1000:
+                        self._queue[identifier].pop(0)
+                    self._queue[identifier].append(result)
+            except KeyboardInterrupt:
+                self.stop()
+                break
+
+
+looper = Looper()

zrb/task/path_checker.py

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