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

zrb/task/notifier.py

@@ -1,7 +1,9 @@
 import os
 import subprocess
 
+from zrb.helper.accessories.color import colored
 from zrb.helper.accessories.icon import get_random_icon
+from zrb.helper.log import logger
 from zrb.helper.string.modification import double_quote
 from zrb.helper.typecheck import typechecked
 from zrb.helper.typing import Any, Callable, Iterable, JinjaTemplate, Optional, Union
@@ -21,6 +23,8 @@ 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.notifier", attrs=["dark"]))
+
 _CURRENT_DIR = os.path.dirname(__file__)
 _NOTIFY_PS1_PATH = os.path.realpath(
     os.path.abspath(

zrb/task/parallel.py

@@ -1,9 +1,13 @@
 from abc import ABC, abstractmethod
 
+from zrb.helper.accessories.color import colored
+from zrb.helper.log import logger
 from zrb.helper.typecheck import typechecked
 from zrb.helper.typing import List, TypeVar, Union
 from zrb.task.any_task import AnyTask
 
+logger.debug(colored("Loading zrb.task.parallel", attrs=["dark"]))
+
 TParallel = TypeVar("TParallel", bound="Parallel")
 
 

zrb/task/path_checker.py

@@ -1,4 +1,6 @@
+from zrb.helper.accessories.color import colored
 from zrb.helper.file.match import get_file_names
+from zrb.helper.log import logger
 from zrb.helper.typecheck import typechecked
 from zrb.helper.typing import (
     Any,
@@ -26,6 +28,8 @@ 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.path_checker", attrs=["dark"]))
+
 TPathChecker = TypeVar("TPathChecker", bound="PathChecker")
 
 
@@ -95,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

@@ -1,6 +1,8 @@
 import os
 
+from zrb.helper.accessories.color import colored
 from zrb.helper.file.match import get_file_names
+from zrb.helper.log import logger
 from zrb.helper.typecheck import typechecked
 from zrb.helper.typing import (
     Any,
@@ -23,17 +25,19 @@ 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
 from zrb.task_input.any_input import AnyInput
 
+logger.debug(colored("Loading zrb.task.path_watcher", attrs=["dark"]))
+
 TPathWatcher = TypeVar("TPathWatcher", bound="PathWatcher")
 
 
 @typechecked
-class PathWatcher(Checker):
+class PathWatcher(Watcher):
     """
     PathWatcher will wait for any changes specified on  path.
 
@@ -45,6 +49,8 @@ class PathWatcher(Checker):
     - <task-name>.deleted-file
     """
 
+    __init_times: Mapping[str, Mapping[str, float]] = {}
+
     def __init__(
         self,
         name: str = "watch-path",
@@ -73,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,
@@ -103,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()
@@ -114,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)
@@ -124,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]:
@@ -132,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

@@ -1,5 +1,7 @@
 import socket
 
+from zrb.helper.accessories.color import colored
+from zrb.helper.log import logger
 from zrb.helper.typecheck import typechecked
 from zrb.helper.typing import (
     Any,
@@ -26,6 +28,8 @@ 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.port_checker", attrs=["dark"]))
+
 TPortChecker = TypeVar("TPortChecker", bound="PortChecker")
 
 
@@ -105,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

@@ -1,7 +1,9 @@
 import asyncio
 import copy
 
+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.task.any_task import AnyTask
@@ -20,6 +22,8 @@ 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.recurring_task", attrs=["dark"]))
+
 
 class RunConfig:
     def __init__(
@@ -111,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/remote_cmd_task.py

@@ -1,6 +1,8 @@
 import os
 import pathlib
 
+from zrb.helper.accessories.color import colored
+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
@@ -20,6 +22,8 @@ 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.remote_cmd_task", attrs=["dark"]))
+
 _CURRENT_DIR = os.path.dirname(__file__)
 _SHELL_SCRIPT_DIR = os.path.join(_CURRENT_DIR, "..", "shell-scripts")
 with open(os.path.join(_SHELL_SCRIPT_DIR, "ssh-util.sh")) as file:

zrb/task/resource_maker.py

@@ -1,4 +1,6 @@
+from zrb.helper.accessories.color import colored
 from zrb.helper.file.copy_tree import copy_tree
+from zrb.helper.log import logger
 from zrb.helper.typecheck import typechecked
 from zrb.helper.typing import (
     Any,
@@ -35,6 +37,8 @@ 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.resource_maker", attrs=["dark"]))
+
 Replacement = Mapping[str, JinjaTemplate]
 ReplacementMutator = Callable[[AnyTask, Replacement], Replacement]
 TResourceMaker = TypeVar("TResourceMaker", bound="ResourceMaker")
@@ -140,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/rsync_task.py

@@ -1,6 +1,8 @@
 import os
 import pathlib
 
+from zrb.helper.accessories.color import colored
+from zrb.helper.log import logger
 from zrb.helper.typecheck import typechecked
 from zrb.helper.typing import Any, Callable, Iterable, JinjaTemplate, Optional, Union
 from zrb.task.any_task import AnyTask
@@ -20,6 +22,8 @@ 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.rsync_task", attrs=["dark"]))
+
 _CURRENT_DIR = os.path.dirname(__file__)
 _SHELL_SCRIPT_DIR = os.path.join(_CURRENT_DIR, "..", "shell-scripts")
 with open(os.path.join(_SHELL_SCRIPT_DIR, "rsync-util.sh")) as file:

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/task.py

@@ -1,6 +1,10 @@
+from zrb.helper.accessories.color import colored
+from zrb.helper.log import logger
 from zrb.helper.typecheck import typechecked
 from zrb.task.base_task.base_task import BaseTask
 
+logger.debug(colored("Loading zrb.task.task", attrs=["dark"]))
+
 
 @typechecked
 class Task(BaseTask):