zrb 0.6.0__py3-none-any.whl → 0.6.1__py3-none-any.whl

zrb/task/recurring_task.py

@@ -1,29 +1,33 @@
-from zrb.helper.typing import (
-    Any, Callable, Iterable, List, Mapping, Optional, Union
-)
-from zrb.helper.typecheck import typechecked
+import asyncio
+import copy
+
 from zrb.helper.accessories.name import get_random_name
-from zrb.task.base_task.base_task import BaseTask
+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
 from zrb.task.any_task_event_handler import (
-    OnTriggered, OnWaiting, OnSkipped, OnStarted, OnReady, OnRetry, OnFailed
+    OnFailed,
+    OnReady,
+    OnRetry,
+    OnSkipped,
+    OnStarted,
+    OnTriggered,
+    OnWaiting,
 )
+from zrb.task.base_task.base_task import BaseTask
 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
 
-import asyncio
-import copy
-
 
-class RunConfig():
+class RunConfig:
     def __init__(
         self,
         fn: Callable[..., Any],
         args: List[Any],
         kwargs: Mapping[Any, Any],
-        execution_id: str
+        execution_id: str,
     ):
         self.fn = fn
         self.args = args
@@ -36,14 +40,14 @@ class RunConfig():
 
 @typechecked
 class RecurringTask(BaseTask):
-    '''
+    """
     A class representing a recurring task that is triggered based on
     specified conditions.
 
     Examples:
 
         >>> from zrb import RecurringTask
-    '''
+    """
 
     def __init__(
         self,
@@ -57,7 +61,7 @@ class RecurringTask(BaseTask):
         env_files: Iterable[EnvFile] = [],
         icon: Optional[str] = None,
         color: Optional[str] = None,
-        description: str = '',
+        description: str = "",
         upstreams: Iterable[AnyTask] = [],
         on_triggered: Optional[OnTriggered] = None,
         on_waiting: Optional[OnWaiting] = None,
@@ -71,7 +75,7 @@ class RecurringTask(BaseTask):
         retry: int = 0,
         retry_interval: float = 1,
         should_execute: Union[bool, str, Callable[..., bool]] = True,
-        return_upstream_result: bool = False
+        return_upstream_result: bool = False,
     ):
         self._task: AnyTask = task.copy()
         inputs = list(inputs) + self._task._get_combined_inputs()
@@ -102,9 +106,7 @@ class RecurringTask(BaseTask):
             should_execute=should_execute,
             return_upstream_result=return_upstream_result,
         )
-        self._triggers: List[AnyTask] = [
-            trigger.copy() for trigger in triggers
-        ]
+        self._triggers: List[AnyTask] = [trigger.copy() for trigger in triggers]
         self._run_configs: List[RunConfig] = []
         self._single_execution = single_execution
 
@@ -116,29 +118,24 @@ class RecurringTask(BaseTask):
         for trigger in self._triggers:
             trigger.add_input(*self._get_inputs())
             trigger.add_env(*self._get_envs())
-            trigger_coroutines.append(asyncio.create_task(
-                trigger._set_keyval(
-                    kwargs=new_kwargs, env_prefix=env_prefix
+            trigger_coroutines.append(
+                asyncio.create_task(
+                    trigger._set_keyval(kwargs=new_kwargs, env_prefix=env_prefix)
                 )
-            ))
+            )
         await asyncio.gather(*trigger_coroutines)
 
     async def run(self, *args: Any, **kwargs: Any):
         await asyncio.gather(
             asyncio.create_task(self.__check_trigger(*args, **kwargs)),
-            asyncio.create_task(self.__run_from_queue())
+            asyncio.create_task(self.__run_from_queue()),
         )
 
     async def __check_trigger(self, *args: Any, **kwargs: Any):
-        task_kwargs = {
-            key: kwargs[key]
-            for key in kwargs if key not in ['_task']
-        }
+        task_kwargs = {key: kwargs[key] for key in kwargs if key not in ["_task"]}
         is_first_time = True
         while True:
-            execution_id = get_random_name(
-                add_random_digit=True, digit_count=5
-            )
+            execution_id = get_random_name(add_random_digit=True, digit_count=5)
             # Create trigger functions
             trigger_functions = []
             for trigger in self._triggers:
@@ -147,10 +144,10 @@ class RecurringTask(BaseTask):
                 trigger_function = trigger_copy.to_function(
                     is_async=True, raise_error=False, show_done_info=False
                 )
-                trigger_functions.append(asyncio.create_task(
-                    trigger_function(*args, **task_kwargs)
-                ))
-            self.print_out_dark('Waiting for next trigger')
+                trigger_functions.append(
+                    asyncio.create_task(trigger_function(*args, **task_kwargs))
+                )
+            self.print_out_dark("Waiting for next trigger")
             # Mark task as done since trigger has been defined.
             if is_first_time:
                 await self._mark_done()
@@ -171,13 +168,10 @@ class RecurringTask(BaseTask):
             fn = task_copy.to_function(
                 is_async=True, raise_error=False, show_done_info=False
             )
-            self.print_out_dark(f'Add execution to the queue: {execution_id}')
+            self.print_out_dark(f"Add execution to the queue: {execution_id}")
             self._run_configs.append(
                 RunConfig(
-                    fn=fn,
-                    args=args,
-                    kwargs=task_kwargs,
-                    execution_id=execution_id
+                    fn=fn, args=args, kwargs=task_kwargs, execution_id=execution_id
                 )
             )
 
@@ -190,12 +184,12 @@ class RecurringTask(BaseTask):
                 # Drain the queue, leave only the latest task
                 while len(self._run_configs) > 1:
                     run_config = self._run_configs.pop(0)
-                    self.print_out_dark(f'Skipping {run_config.execution_id}')
+                    self.print_out_dark(f"Skipping {run_config.execution_id}")
                     self.clear_xcom(execution_id=run_config.execution_id)
             # Run task
             run_config = self._run_configs.pop(0)
-            self.print_out_dark(f'Executing {run_config.execution_id}')
-            self.print_out_dark(f'{len(self._run_configs)} tasks left')
+            self.print_out_dark(f"Executing {run_config.execution_id}")
+            self.print_out_dark(f"{len(self._run_configs)} tasks left")
             await run_config.run()
             self.clear_xcom(execution_id=run_config.execution_id)
             self._play_bell()

zrb/task/remote_cmd_task.py

@@ -1,32 +1,37 @@
-from zrb.helper.typing import Any, Callable, Iterable, Optional, Union
+import os
+import pathlib
+
 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 (
-    OnTriggered, OnWaiting, OnSkipped, OnStarted, OnReady, OnRetry, OnFailed
+    OnFailed,
+    OnReady,
+    OnRetry,
+    OnSkipped,
+    OnStarted,
+    OnTriggered,
+    OnWaiting,
 )
+from zrb.task.base_remote_cmd_task import BaseRemoteCmdTask, RemoteConfig
+from zrb.task.cmd_task import CmdTask, CmdVal
 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
-from zrb.task.cmd_task import CmdVal, CmdTask
-from zrb.task.base_remote_cmd_task import RemoteConfig, BaseRemoteCmdTask
-
-import os
-import pathlib
-
 
 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:
+SHELL_SCRIPT_DIR = os.path.join(CURRENT_DIR, "..", "shell-scripts")
+with open(os.path.join(SHELL_SCRIPT_DIR, "ssh-util.sh")) as file:
     SSH_UTIL_SCRIPT = file.read()
 
 ensure_ssh_is_installed = CmdTask(
-    name='ensure-ssh-is-installed',
+    name="ensure-ssh-is-installed",
     cmd_path=[
-        os.path.join(SHELL_SCRIPT_DIR, '_common-util.sh'),
-        os.path.join(SHELL_SCRIPT_DIR, 'ensure-ssh-is-installed.sh')
+        os.path.join(SHELL_SCRIPT_DIR, "_common-util.sh"),
+        os.path.join(SHELL_SCRIPT_DIR, "ensure-ssh-is-installed.sh"),
     ],
-    preexec_fn=None
+    preexec_fn=None,
 )
 
 
@@ -42,10 +47,10 @@ class RemoteCmdTask(BaseRemoteCmdTask):
         env_files: Iterable[EnvFile] = [],
         icon: Optional[str] = None,
         color: Optional[str] = None,
-        description: str = '',
+        description: str = "",
         executable: Optional[str] = None,
-        cmd: CmdVal = '',
-        cmd_path: CmdVal = '',
+        cmd: CmdVal = "",
+        cmd_path: CmdVal = "",
         cwd: Optional[Union[str, pathlib.Path]] = None,
         upstreams: Iterable[AnyTask] = [],
         on_triggered: Optional[OnTriggered] = None,
@@ -62,17 +67,15 @@ class RemoteCmdTask(BaseRemoteCmdTask):
         max_output_line: int = 1000,
         max_error_line: int = 1000,
         preexec_fn: Optional[Callable[[], Any]] = os.setsid,
-        should_execute: Union[bool, str, Callable[..., bool]] = True
+        should_execute: Union[bool, str, Callable[..., bool]] = True,
     ):
-        pre_cmd = '\n'.join([
-            SSH_UTIL_SCRIPT,
-            '_SCRIPT="$(cat <<\'ENDSCRIPT\'',
-        ])
-        post_cmd = '\n'.join([
-            'ENDSCRIPT',
-            ')"',
-            'auth_ssh "$_SCRIPT"'
-        ])
+        pre_cmd = "\n".join(
+            [
+                SSH_UTIL_SCRIPT,
+                "_SCRIPT=\"$(cat <<'ENDSCRIPT'",
+            ]
+        )
+        post_cmd = "\n".join(["ENDSCRIPT", ')"', 'auth_ssh "$_SCRIPT"'])
         BaseRemoteCmdTask.__init__(
             self,
             name=name,
@@ -105,5 +108,5 @@ class RemoteCmdTask(BaseRemoteCmdTask):
             max_output_line=max_output_line,
             max_error_line=max_error_line,
             preexec_fn=preexec_fn,
-            should_execute=should_execute
+            should_execute=should_execute,
         )

zrb/task/resource_maker.py

@@ -1,33 +1,46 @@
+from zrb.helper.file.copy_tree import copy_tree
+from zrb.helper.typecheck import typechecked
 from zrb.helper.typing import (
-    Any, Callable, Iterable, Mapping, Optional, Union, TypeVar, JinjaTemplate
+    Any,
+    Callable,
+    Iterable,
+    JinjaTemplate,
+    Mapping,
+    Optional,
+    TypeVar,
+    Union,
+)
+from zrb.helper.util import (
+    to_camel_case,
+    to_capitalized_human_readable,
+    to_human_readable,
+    to_kebab_case,
+    to_pascal_case,
+    to_snake_case,
 )
-from zrb.helper.typecheck import typechecked
-from zrb.task.base_task.base_task import BaseTask
 from zrb.task.any_task import AnyTask
 from zrb.task.any_task_event_handler import (
-    OnTriggered, OnWaiting, OnSkipped, OnStarted, OnReady, OnRetry, OnFailed
+    OnFailed,
+    OnReady,
+    OnRetry,
+    OnSkipped,
+    OnStarted,
+    OnTriggered,
+    OnWaiting,
 )
+from zrb.task.base_task.base_task import BaseTask
 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
-from zrb.helper.file.copy_tree import copy_tree
-from zrb.helper.util import (
-    to_camel_case, to_pascal_case, to_kebab_case, to_snake_case,
-    to_human_readable, to_capitalized_human_readable
-)
 
 Replacement = Mapping[str, JinjaTemplate]
-ReplacementMutator = Callable[
-    [AnyTask, Replacement],
-    Replacement
-]
-TResourceMaker = TypeVar('TResourceMaker', bound='ResourceMaker')
+ReplacementMutator = Callable[[AnyTask, Replacement], Replacement]
+TResourceMaker = TypeVar("TResourceMaker", bound="ResourceMaker")
 
 
 @typechecked
 class ResourceMaker(BaseTask):
-
     def __init__(
         self,
         name: str,
@@ -42,7 +55,7 @@ class ResourceMaker(BaseTask):
         env_files: Iterable[EnvFile] = [],
         icon: Optional[str] = None,
         color: Optional[str] = None,
-        description: str = '',
+        description: str = "",
         upstreams: Iterable[AnyTask] = [],
         on_triggered: Optional[OnTriggered] = None,
         on_waiting: Optional[OnWaiting] = None,
@@ -52,7 +65,7 @@ class ResourceMaker(BaseTask):
         on_retry: Optional[OnRetry] = None,
         on_failed: Optional[OnFailed] = None,
         should_execute: Union[bool, JinjaTemplate, Callable[..., bool]] = True,
-        skip_parsing: Optional[Iterable[str]] = None
+        skip_parsing: Optional[Iterable[str]] = None,
     ):
         BaseTask.__init__(
             self,
@@ -76,7 +89,7 @@ class ResourceMaker(BaseTask):
             checking_interval=0.1,
             retry=0,
             retry_interval=0,
-            should_execute=should_execute
+            should_execute=should_execute,
         )
         self._template_path = template_path
         self._destination_path = destination_path
@@ -93,59 +106,60 @@ class ResourceMaker(BaseTask):
             self._skip_parsing: Iterable[str] = skip_parsing
             return
         self._skip_parsing: Iterable[str] = [
-            '*.mp3', '*.pdf', '*.exe', '*.dll', '*.bin', '*.iso', '*.png',
-            '*.jpg', '*.gif', '*.ico'
+            "*.mp3",
+            "*.pdf",
+            "*.exe",
+            "*.dll",
+            "*.bin",
+            "*.iso",
+            "*.png",
+            "*.jpg",
+            "*.gif",
+            "*.ico",
         ]
 
     def to_function(
         self,
-        env_prefix: str = '',
+        env_prefix: str = "",
         raise_error: bool = True,
         is_async: bool = False,
-        show_done_info: bool = True
+        show_done_info: bool = True,
     ) -> Callable[..., bool]:
-        return super().to_function(
-            env_prefix, raise_error, is_async, show_done_info
-        )
+        return super().to_function(env_prefix, raise_error, is_async, show_done_info)
 
     async def run(self, *args: Any, **kwargs: Any) -> bool:
         # render parameters
         template_path = self.render_str(self._template_path)
         destination_path = self.render_str(self._destination_path)
         # render excludes
-        self.log_debug(f'Render excludes: {self._excludes}')
+        self.log_debug(f"Render excludes: {self._excludes}")
         excludes = [self.render_str(exclude) for exclude in self._excludes]
-        self.log_debug(f'Rendered excludes: {excludes}')
+        self.log_debug(f"Rendered excludes: {excludes}")
         # render replacements
-        self.log_debug(f'Render replacements: {self._replacements}')
+        self.log_debug(f"Render replacements: {self._replacements}")
         rendered_replacements: Mapping[str, str] = {
-            old: self.render_str(new)
-            for old, new in self._replacements.items()
+            old: self.render_str(new) for old, new in self._replacements.items()
         }
-        self.log_debug(f'Rendered replacements: {rendered_replacements}')
+        self.log_debug(f"Rendered replacements: {rendered_replacements}")
         if self._replacement_mutator is not None:
-            self.log_debug('Apply replacement mutator')
+            self.log_debug("Apply replacement mutator")
             rendered_replacements = self._replacement_mutator(
                 self, rendered_replacements
             )
-        self.log_debug(
-            f'Apply default replacement mutator: {rendered_replacements}'
-        )
-        rendered_replacements = self._default_mutate_replacements(
-            rendered_replacements
-        )
-        self.log_debug(f'Final replacement: {rendered_replacements}')
-        self.print_out_dark(f'Template: {template_path}')
-        self.print_out_dark(f'Destination: {destination_path}')
-        self.print_out_dark(f'Replacements: {rendered_replacements}')
-        self.print_out_dark(f'Excludes: {excludes}')
-        self.print_out_dark(f'Skip parsing: {self._skip_parsing}')
+        self.log_debug(f"Apply default replacement mutator: {rendered_replacements}")
+        rendered_replacements = self._default_mutate_replacements(rendered_replacements)
+        self.log_debug(f"Final replacement: {rendered_replacements}")
+        self.print_out_dark(f"Template: {template_path}")
+        self.print_out_dark(f"Destination: {destination_path}")
+        self.print_out_dark(f"Replacements: {rendered_replacements}")
+        self.print_out_dark(f"Excludes: {excludes}")
+        self.print_out_dark(f"Skip parsing: {self._skip_parsing}")
         await copy_tree(
             src=template_path,
             dst=destination_path,
             replacements=rendered_replacements,
             excludes=excludes,
-            skip_parsing=self._skip_parsing
+            skip_parsing=self._skip_parsing,
         )
         return True
 
@@ -153,18 +167,18 @@ class ResourceMaker(BaseTask):
         self, rendered_replacements: Mapping[str, str]
     ) -> Mapping[str, str]:
         transformations: Mapping[str, Callable[[str], str]] = {
-            'Pascal': to_pascal_case,
-            'kebab': to_kebab_case,
-            'camel': to_camel_case,
-            'snake': to_snake_case,
-            'human readable': to_human_readable,
-            'Human readable': to_capitalized_human_readable,
+            "Pascal": to_pascal_case,
+            "kebab": to_kebab_case,
+            "camel": to_camel_case,
+            "snake": to_snake_case,
+            "human readable": to_human_readable,
+            "Human readable": to_capitalized_human_readable,
         }
         keys = list(rendered_replacements.keys())
         for key in keys:
             value = rendered_replacements[key]
             for prefix, transform in transformations.items():
-                prefixed_key = transform(prefix + ' ' + key)
+                prefixed_key = transform(prefix + " " + key)
                 if prefixed_key in rendered_replacements:
                     continue
                 transformed_value = transform(value)

zrb/task/rsync_task.py

@@ -1,35 +1,38 @@
-from zrb.helper.typing import (
-    Any, Callable, Iterable, Optional, Union, JinjaTemplate
-)
+import os
+import pathlib
+
 from zrb.helper.typecheck import typechecked
+from zrb.helper.typing import Any, Callable, Iterable, JinjaTemplate, Optional, Union
 from zrb.task.any_task import AnyTask
 from zrb.task.any_task_event_handler import (
-    OnTriggered, OnWaiting, OnSkipped, OnStarted, OnReady, OnRetry, OnFailed
+    OnFailed,
+    OnReady,
+    OnRetry,
+    OnSkipped,
+    OnStarted,
+    OnTriggered,
+    OnWaiting,
 )
+from zrb.task.base_remote_cmd_task import BaseRemoteCmdTask, RemoteConfig
+from zrb.task.cmd_task import CmdTask
 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
-from zrb.task.cmd_task import CmdTask
-from zrb.task.base_remote_cmd_task import RemoteConfig, BaseRemoteCmdTask
-
-import os
-import pathlib
-
 
 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:
+SHELL_SCRIPT_DIR = os.path.join(CURRENT_DIR, "..", "shell-scripts")
+with open(os.path.join(SHELL_SCRIPT_DIR, "rsync-util.sh")) as file:
     RSYNC_UTIL_SCRIPT = file.read()
 
 ensure_rsync_is_installed = CmdTask(
-    name='ensure-ssh-is-installed',
+    name="ensure-ssh-is-installed",
     cmd_path=[
-        os.path.join(SHELL_SCRIPT_DIR, '_common-util.sh'),
-        os.path.join(SHELL_SCRIPT_DIR, 'ensure-ssh-is-installed.sh'),
-        os.path.join(SHELL_SCRIPT_DIR, 'ensure-rsync-is-installed.sh')
+        os.path.join(SHELL_SCRIPT_DIR, "_common-util.sh"),
+        os.path.join(SHELL_SCRIPT_DIR, "ensure-ssh-is-installed.sh"),
+        os.path.join(SHELL_SCRIPT_DIR, "ensure-rsync-is-installed.sh"),
     ],
-    preexec_fn=None
+    preexec_fn=None,
 )
 
 
@@ -49,7 +52,7 @@ class RsyncTask(BaseRemoteCmdTask):
         env_files: Iterable[EnvFile] = [],
         icon: Optional[str] = None,
         color: Optional[str] = None,
-        description: str = '',
+        description: str = "",
         executable: Optional[str] = None,
         cwd: Optional[Union[str, pathlib.Path]] = None,
         upstreams: Iterable[AnyTask] = [],
@@ -67,7 +70,7 @@ class RsyncTask(BaseRemoteCmdTask):
         max_output_line: int = 1000,
         max_error_line: int = 1000,
         preexec_fn: Optional[Callable[[], Any]] = os.setsid,
-        should_execute: Union[bool, str, Callable[..., bool]] = True
+        should_execute: Union[bool, str, Callable[..., bool]] = True,
     ):
         parsed_src = self._get_parsed_path(is_remote_src, src)
         parsed_dst = self._get_parsed_path(is_remote_dst, dst)
@@ -102,10 +105,10 @@ class RsyncTask(BaseRemoteCmdTask):
             max_output_line=max_output_line,
             max_error_line=max_error_line,
             preexec_fn=preexec_fn,
-            should_execute=should_execute
+            should_execute=should_execute,
         )
 
     def _get_parsed_path(self, is_remote: bool, path: str) -> str:
         if not is_remote:
             return path
-        return '${_CONFIG_USER}@${_CONFIG_HOST}:' + path
+        return "${_CONFIG_USER}@${_CONFIG_HOST}:" + path

zrb/task/task.py

@@ -1,10 +1,11 @@
-from zrb.task.base_task.base_task import BaseTask
 from zrb.helper.typecheck import typechecked
+from zrb.task.base_task.base_task import BaseTask
 
 
 @typechecked
 class Task(BaseTask):
-    '''
+    """
     Alias for BaseTask.
-    '''
+    """
+
     pass