zrb 0.15.1__tar.gz → 0.16.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zrb
-Version: 0.15.1
+Version: 0.16.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.16.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "zrb"
-version = "0.15.1"
+version = "0.16.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.16.0}/src/zrb/__init__.py

@@ -32,6 +32,7 @@ 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.wiki_task import create_wiki_tasks
@@ -74,6 +75,8 @@ assert HTTPChecker
 assert PortChecker
 assert PathChecker
 assert PathWatcher
+assert Controller
+assert Server
 assert TimeWatcher
 assert ResourceMaker
 assert FlowTask

{zrb-0.15.1 → zrb-0.16.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.16.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.16.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,21 @@ 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",
+                trigger_caption="Schedule",
+                trigger_xcom_key="watch-time.scheduled-time",
+            ),
         )
     ],
-    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.16.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,22 @@ 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",
+                trigger_caption="File changes",
+                trigger_xcom_key="watch-path.file",
+            ),
         )
     ],
-    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.16.0}/src/zrb/task/base_task/base_task.py

@@ -140,7 +140,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()

{zrb-0.15.1 → zrb-0.16.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.16.0/src/zrb/task/server.py

@@ -0,0 +1,192 @@
+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:
+        kebab_name = to_kebab_case(self._name)
+        actions = self._actions
+        actions.insert(0, self._get_reschedule_task())
+        task: AnyTask = FlowTask(
+            name=f"{kebab_name}-flow",
+            inputs=self._inputs,
+            envs=self._envs,
+            env_files=self._env_files,
+            steps=[self._triggers, actions],
+        )
+        return task
+
+    def _get_reschedule_task(self) -> AnyTask:
+        kebab_name = to_kebab_case(self._name)
+
+        async def on_ready(task: AnyTask):
+            task = self._get_task()
+            fn = task.to_function(is_async=True)
+            await fn()
+
+        return BaseTask(
+            name=f"{kebab_name}-reschedule",
+            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])