zrb 0.15.1__tar.gz → 0.17.0__tar.gz

{zrb-0.15.1 → zrb-0.17.0}/PKG-INFO

@@ -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 → zrb-0.17.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "zrb"
-version = "0.15.1"
+version = "0.17.0"
 description = "A Framework to Enhance Your Workflow"
 authors = ["Go Frendi Gunawan <gofrendiasgard@gmail.com>"]
 license = "AGPL-3.0-or-later"

{zrb-0.15.1 → zrb-0.17.0}/src/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-0.15.1 → zrb-0.17.0}/src/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-0.15.1 → zrb-0.17.0}/src/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-0.15.1 → zrb-0.17.0}/src/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-0.15.1 → zrb-0.17.0}/src/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-0.15.1 → zrb-0.17.0}/src/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-0.15.1 → zrb-0.17.0}/src/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-0.15.1 → zrb-0.17.0}/src/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-0.15.1 → zrb-0.17.0}/src/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-0.15.1 → zrb-0.17.0}/src/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-0.15.1 → zrb-0.17.0}/src/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-0.15.1 → zrb-0.17.0}/src/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-0.15.1 → zrb-0.17.0}/src/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-0.17.0/src/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-0.15.1 → zrb-0.17.0}/src/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-0.15.1 → zrb-0.17.0}/src/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-0.15.1 → zrb-0.17.0}/src/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-0.15.1 → zrb-0.17.0}/src/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-0.15.1 → zrb-0.17.0}/src/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