zrb 0.0.108__py3-none-any.whl → 0.0.110__py3-none-any.whl

zrb/action/runner.py

@@ -27,10 +27,10 @@ class Runner():
         logger.info(colored('Runner created', attrs=['dark']))
 
     def register(self, task: AnyTask):
-        cmd_name = task.get_complete_cmd_name()
+        task.set_has_cli_interface()
+        cmd_name = task.get_full_cmd_name()
         logger.debug(colored(f'Register task: {cmd_name}', attrs=['dark']))
         self._tasks.append(task)
-        task.set_has_cli_interface()
         logger.debug(colored(f'Task registered: {cmd_name}', attrs=['dark']))
 
     def serve(self, cli: click.Group) -> click.Group:
@@ -77,7 +77,7 @@ class Runner():
         return group
 
     def _create_cli_command(self, task: AnyTask) -> click.Command:
-        task_inputs = task.get_all_inputs()
+        task_inputs = task._get_combined_inputs()
         task_cmd_name = task.get_cmd_name()
         task_description = task.get_description()
         task_function = task.to_function(

zrb/builtin/git.py

@@ -1,7 +1,6 @@
 from zrb.helper.typing import Any
 from zrb.builtin.group import git_group
 from zrb.task.decorator import python_task
-from zrb.task.task import Task
 from zrb.task_input.str_input import StrInput
 from zrb.task_input.bool_input import BoolInput
 from zrb.runner import runner
@@ -26,7 +25,7 @@ from zrb.helper.python_task import show_lines
             prompt='Commit hash/Tag',
             default='HEAD'
         ),
-       BoolInput(
+        BoolInput(
             name='include-new',
             description='include new files',
             prompt='Include new files',
@@ -52,7 +51,6 @@ async def get_file_changes(*args: Any, **kwargs: Any):
     include_new = kwargs.get('include_new', True)
     include_removed = kwargs.get('include_removed', True)
     include_updated = kwargs.get('include_updated', True)
-    task: Task = kwargs['_task']
     modified_file_states = get_modified_file_states(commit)
     modified_file_keys = []
     output = []

zrb/helper/accessories/name.py

@@ -10,19 +10,29 @@ def get_random_name(
     digit_count: int = 4
 ) -> str:
     prefixes = [
-        "aurum", "argentum", "platinum", "mercurius", "sulfur", "sal",
-        "luna", "sol", "ferrum", "cuprum", "argent", "aurora", "citrin",
-        "coral", "diamond", "dragon", "emerald", "garnet", "jade", "onyx",
-        "opal", "pearl", "ruby", "sapphire", "topaz", "turquoise", "verde",
-        "zircon"
+        'albedo', 'argent', 'argentum', 'aurora', 'aurum', 'azure',
+        'basilisk', 'cerulean', 'chimeric', 'citrin', 'coral', 'crimson',
+        'diamond', 'draco', 'dragon', 'emerald', 'ethereal', 'ferrum',
+        'flammeus', 'garnet', 'glacial', 'glimmering', 'glistening', 'golden',
+        'helios', 'igneous', 'imperial', 'jade', 'luminous', 'luna', 'lunar',
+        'mystic', 'nephrite', 'nocturnal', 'obsidian', 'opal', 'pearl',
+        'platinum', 'prismatic', 'ruby', 'sapphire', 'serpentine', 'silver',
+        'sol', 'solar', 'spiritual', 'stellar',  'tempest', 'topaz',
+        'turquoise', 'verde', 'vermillion', 'vitreous', 'zephyr', 'zircon'
     ]
     suffixes = [
-        "philosophorum", "spiritus", "tinctura", "essentia", "elixir",
-        "praeparatum", "aether", "vitae", "lapis", "metallum", "aureum",
-        "caelestis", "chrysopoeia", "cosmicum", "deum", "draconis",
-        "elementorum", "hermetica", "illuminationis", "magnum", "mysticum",
-        "occultum", "omnipotentis", "philosophia", "praestantissimum",
-        "quintessentia", "regeneratio", "universalis"
+        'aether', 'albedo', 'alchemy', 'arcana', 'aureum', 'aetheris',
+        'anima', 'astralis', 'caelestis', 'chrysopoeia', 'cosmicum',
+        'crystallum', 'deum', 'divinitas', 'draconis', 'elementorum', 'elixir',
+        'essentia', 'eternis', 'ethereus', 'fatum', 'flamma', 'fulgur',
+        'hermetica', 'ignis', 'illuminationis', 'imperium', 'incantatum',
+        'infinitum', 'lapis', 'lux', 'magicae', 'magnum', 'materia',
+        'metallum', 'mysticum', 'natura', 'occultum', 'omnipotentis',
+        'opulentia', 'philosophia', 'philosophorum', 'praeparatum',
+        'praestantissimum', 'prima', 'primordium', 'quintessentia',
+        'regeneratio', 'ritualis', 'sanctum', 'spiritus', 'tenebris',
+        'terra', 'tinctura', 'transmutationis', 'universalis', 'vapores',
+        'venenum', 'veritas', 'vitae', 'volatus'
     ]
     prefix = random.choice(prefixes)
     suffix = random.choice(suffixes)

zrb/helper/env_map/fetch.py

@@ -16,7 +16,7 @@ def fetch_env_map_from_group(
         sub_env_map: Mapping[str, str] = fetch_env_map_from_group(
             env_map, sub_group
         )
-        env_map = cascade_env_map(env_map, sub_env_map)
+        env_map = _cascade_env_map(env_map, sub_env_map)
     return env_map
 
 
@@ -25,33 +25,33 @@ def fetch_env_map_from_task(
     env_map: Mapping[str, str], task: AnyTask
 ):
     task_env_map: Mapping[str, str] = {}
-    for env_file in task.get_env_files():
+    for env_file in task._get_env_files():
         envs = env_file.get_envs()
-        task_env_map = add_envs_to_env_map(task_env_map, envs)
-    task_env_map = add_envs_to_env_map(task_env_map, task._envs)
-    env_map = cascade_env_map(env_map, task_env_map)
-    for upstream in task.get_upstreams():
+        task_env_map = _add_envs_to_env_map(task_env_map, envs)
+    task_env_map = _add_envs_to_env_map(task_env_map, task._envs)
+    env_map = _cascade_env_map(env_map, task_env_map)
+    for upstream in task._get_upstreams():
         task_env_map = fetch_env_map_from_task(env_map, upstream)
-    for checker in task.get_checkers():
+    for checker in task._get_checkers():
         task_env_map = fetch_env_map_from_task(env_map, checker)
     return env_map
 
 
 @typechecked
-def add_envs_to_env_map(
+def _add_envs_to_env_map(
     env_map: Mapping[str, str], envs: List[Env]
 ) -> Mapping[str, str]:
     for env in envs:
         if env.os_name == '':
             continue
-        env_name = get_env_name(env)
-        env_default = get_env_default(env)
+        env_name = _get_env_name(env)
+        env_default = _get_env_default(env)
         env_map[env_name] = env_default
     return env_map
 
 
 @typechecked
-def cascade_env_map(
+def _cascade_env_map(
     env_map: Mapping[str, str],
     other_env_map: Mapping[str, str]
 ) -> Mapping[str, str]:
@@ -63,14 +63,14 @@ def cascade_env_map(
 
 
 @typechecked
-def get_env_name(env: Env) -> str:
+def _get_env_name(env: Env) -> str:
     if env.os_name is None:
         return env.name
     return env.os_name
 
 
 @typechecked
-def get_env_default(env: Env) -> str:
+def _get_env_default(env: Env) -> str:
     if is_probably_jinja(env.default):
         return ''
     return env.default

zrb/shell-scripts/rsync-util.sh

@@ -2,11 +2,11 @@ set -e
 auth_rsync(){
     if [ "$_CONFIG_SSH_KEY" != "" ]
     then
-        rsync -avz -e "ssh -i $_CONFIG_SSH_KEY -p $_CONFIG_PORT" $@
+        rsync --mkpath -avz -e "ssh -i $_CONFIG_SSH_KEY -p $_CONFIG_PORT" $@
     elif [ "$_CONFIG_PASSWORD" != "" ]
     then
-        sshpass -p "$_CONFIG_PASSWORD" rsync -avz -e "ssh -p $_CONFIG_PORT" $@
+        sshpass -p "$_CONFIG_PASSWORD" rsync --mkpath -avz -e "ssh -p $_CONFIG_PORT" $@
     else
-        rsync -avz -e "ssh -p $_CONFIG_PORT" $@
+        rsync --mkpath -avz -e "ssh -p $_CONFIG_PORT" $@
     fi
 }

zrb/task/any_task.py

@@ -65,19 +65,35 @@ class AnyTask(ABC):
         pass
 
     @abstractmethod
-    def add_upstreams(self, *upstreams: TAnyTask):
+    def add_upstream(self, *upstreams: TAnyTask):
         pass
 
     @abstractmethod
-    def add_inputs(self, *inputs: AnyInput):
+    def insert_input(self, *inputs: AnyInput):
         pass
 
     @abstractmethod
-    def add_envs(self, *envs: Env):
+    def add_input(self, *inputs: AnyInput):
         pass
 
     @abstractmethod
-    def add_env_files(self, *env_files: EnvFile):
+    def insert_env(self, *envs: Env):
+        pass
+
+    @abstractmethod
+    def add_env(self, *envs: Env):
+        pass
+
+    @abstractmethod
+    def insert_env_file(self, *env_files: EnvFile):
+        pass
+
+    @abstractmethod
+    def add_env_file(self, *env_files: EnvFile):
+        pass
+
+    @abstractmethod
+    def _set_execution_id(self, execution_id: str):
         pass
 
     @abstractmethod
@@ -114,6 +130,10 @@ class AnyTask(ABC):
     def set_checking_interval(self, new_checking_interval: Union[float, int]):
         pass
 
+    @abstractmethod
+    def get_execution_id(self) -> str:
+        pass
+
     @abstractmethod
     def get_icon(self) -> str:
         pass
@@ -131,31 +151,51 @@ class AnyTask(ABC):
         pass
 
     @abstractmethod
-    def get_complete_cmd_name(self) -> str:
+    def get_full_cmd_name(self) -> str:
+        pass
+
+    @abstractmethod
+    def inject_env_files(self):
         pass
 
     @abstractmethod
-    def get_env_files(self) -> List[EnvFile]:
+    def _get_env_files(self) -> List[EnvFile]:
         pass
 
     @abstractmethod
-    def get_envs(self) -> List[Env]:
+    def inject_envs(self):
         pass
 
     @abstractmethod
-    def get_inputs(self) -> List[AnyInput]:
+    def _get_envs(self) -> List[Env]:
         pass
 
     @abstractmethod
-    def get_checkers(self) -> Iterable[TAnyTask]:
+    def inject_inputs(self):
         pass
 
     @abstractmethod
-    def get_upstreams(self) -> Iterable[TAnyTask]:
+    def _get_inputs(self) -> List[AnyInput]:
         pass
 
     @abstractmethod
-    def get_all_inputs(self) -> Iterable[AnyInput]:
+    def inject_checkers(self):
+        pass
+
+    @abstractmethod
+    def _get_checkers(self) -> Iterable[TAnyTask]:
+        pass
+
+    @abstractmethod
+    def inject_upstreams(self):
+        pass
+
+    @abstractmethod
+    def _get_upstreams(self) -> Iterable[TAnyTask]:
+        pass
+
+    @abstractmethod
+    def _get_combined_inputs(self) -> Iterable[AnyInput]:
         pass
 
     @abstractmethod
@@ -198,12 +238,6 @@ class AnyTask(ABC):
     def get_env_map(self) -> Mapping[str, Any]:
         pass
 
-    @abstractmethod
-    def inject_env_map(
-        self, env_map: Mapping[str, str], override: bool = False
-    ):
-        pass
-
     @abstractmethod
     def render_any(
         self, val: Any, data: Optional[Mapping[str, Any]] = None

zrb/task/base_remote_cmd_task.py

@@ -2,6 +2,7 @@ from zrb.helper.typing import (
     Any, Callable, Iterable, Mapping, Optional, Union, TypeVar
 )
 from zrb.helper.typecheck import typechecked
+from zrb.helper.util import to_snake_case
 from zrb.task.any_task import AnyTask
 from zrb.task.any_task_event_handler import (
     OnTriggered, OnWaiting, OnSkipped, OnStarted, OnReady, OnRetry, OnFailed
@@ -34,13 +35,15 @@ class RemoteConfig:
         user: str = '',
         password: str = '',
         ssh_key: str = '',
-        port: int = 22
+        port: int = 22,
+        config_map: Optional[Mapping[str, str]] = None
     ):
         self.host = host
         self.user = user
         self.password = password
         self.ssh_key = ssh_key
         self.port = port
+        self.config_map = {} if config_map is None else config_map
 
 
 @typechecked
@@ -123,28 +126,50 @@ class SingleBaseRemoteCmdTask(CmdTask):
     def copy(self) -> TSingleBaseRemoteCmdTask:
         return copy.deepcopy(self)
 
-    def _get_shell_env_map(self) -> Mapping[str, Any]:
-        env_map = super()._get_shell_env_map()
-        env_map['_CONFIG_HOST'] = self.render_str(self._remote_config.host)
-        env_map['_CONFIG_PORT'] = str(self.render_int(
-            self._remote_config.port)
-        )
-        env_map['_CONFIG_SSH_KEY'] = self.render_str(
-            self._remote_config.ssh_key
-        )
-        env_map['_CONFIG_USER'] = self.render_str(self._remote_config.user)
-        env_map['_CONFIG_PASSWORD'] = self.render_str(
-            self._remote_config.password
+    def inject_envs(self):
+        super().inject_envs()
+        # add remote config properties as env
+        self.add_env(
+            Env(
+                name='_CONFIG_HOST', os_name='',
+                default=self.render_str(self._remote_config.host)
+            ),
+            Env(
+                name='_CONFIG_PORT', os_name='',
+                default=str(self.render_int(self._remote_config.port))
+            ),
+            Env(
+                name='_CONFIG_SSH_KEY', os_name='',
+                default=self.render_str(self._remote_config.ssh_key)
+            ),
+            Env(
+                name='_CONFIG_USER', os_name='',
+                default=self.render_str(self._remote_config.user)
+            ),
+            Env(
+                name='_CONFIG_PASSWORD', os_name='',
+                default=self.render_str(self._remote_config.password)
+            ),
         )
-        return env_map
+        for key, val in self._remote_config.config_map.items():
+            upper_snake_key = to_snake_case(key).upper()
+            rendered_val = self.render_str(val)
+            # add remote config map as env
+            self.add_env(
+                Env(
+                    name='_CONFIG_MAP_' + upper_snake_key,
+                    os_name='',
+                    default=rendered_val
+                )
+            )
 
-    def _get_cmd_str(self, *args: Any, **kwargs: Any) -> str:
+    def get_cmd_script(self, *args: Any, **kwargs: Any) -> str:
         cmd_str = '\n'.join([
-            self._create_cmd_str(
+            self._create_cmd_script(
                 self._pre_cmd_path, self._pre_cmd, *args, **kwargs
             ),
-            super()._get_cmd_str(*args, **kwargs),
-            self._create_cmd_str(
+            super().get_cmd_script(*args, **kwargs),
+            self._create_cmd_script(
                 self._post_cmd_path, self._post_cmd, *args, **kwargs
             ),
         ])

zrb/task/base_task.py

@@ -12,11 +12,13 @@ from zrb.task.base_task_composite import (
 )
 from zrb.advertisement import advertisements
 from zrb.task_group.group import Group
+from zrb.task_env.constant import RESERVED_ENV_NAMES
 from zrb.task_env.env import Env
 from zrb.task_env.env_file import EnvFile
 from zrb.task_input.any_input import AnyInput
 from zrb.task_input.constant import RESERVED_INPUT_NAMES
 from zrb.helper.accessories.color import colored
+from zrb.helper.accessories.name import get_random_name
 from zrb.helper.advertisement import get_advertisement
 from zrb.helper.string.modification import double_quote
 from zrb.helper.string.conversion import to_variable_name
@@ -108,30 +110,28 @@ class BaseTask(
         self._is_execution_started: bool = False
         self._args: List[Any] = []
         self._kwargs: Mapping[str, Any] = {}
-        self._allow_add_upstreams: bool = True
 
     def copy(self) -> AnyTask:
         return copy.deepcopy(self)
 
-    def get_all_inputs(self) -> Iterable[AnyInput]:
+    def _get_combined_inputs(self) -> Iterable[AnyInput]:
         ''''
         Getting all inputs of this task and all its upstream, non-duplicated.
         '''
         if self._all_inputs is not None:
             return self._all_inputs
-        self._allow_add_upstreams = False
-        self._allow_add_inputs = False
         self._all_inputs: List[AnyInput] = []
         existing_input_names: Mapping[str, bool] = {}
         # Add task inputs
-        for input_index, first_occurence_task_input in enumerate(self._inputs):
+        inputs = self._get_inputs()
+        for input_index, first_occurence_task_input in enumerate(inputs):
             input_name = first_occurence_task_input.get_name()
             if input_name in existing_input_names:
                 continue
             # Look for all input with the same name in the current task
             task_inputs = [
                 candidate
-                for candidate in self._inputs[input_index:]
+                for candidate in inputs[input_index:]
                 if candidate.get_name() == input_name
             ]
             # Get the last input, and add it to _all_inputs
@@ -139,13 +139,15 @@ class BaseTask(
             self._all_inputs.append(task_input)
             existing_input_names[input_name] = True
         # Add upstream inputs
-        for upstream in self._upstreams:
-            upstream_inputs = upstream.get_all_inputs()
+        for upstream in self._get_upstreams():
+            upstream_inputs = upstream._get_combined_inputs()
             for upstream_input in upstream_inputs:
                 if upstream_input.get_name() in existing_input_names:
                     continue
                 self._all_inputs.append(upstream_input)
                 existing_input_names[upstream_input.get_name()] = True
+        self._allow_add_upstreams = False
+        self._allow_add_inputs = False
         return self._all_inputs
 
     def to_function(
@@ -165,21 +167,6 @@ class BaseTask(
             ))
         return function
 
-    def add_upstreams(self, *upstreams: AnyTask):
-        if not self._allow_add_upstreams:
-            raise Exception(f'Cannot add upstreams on `{self._name}`')
-        self._upstreams += upstreams
-
-    def inject_env_map(
-        self, env_map: Mapping[str, str], override: bool = False
-    ):
-        '''
-        Set new values for current task's env map
-        '''
-        for key, val in env_map.items():
-            if override or key not in self.get_env_map():
-                self._set_env_map(key, val)
-
     async def run(self, *args: Any, **kwargs: Any) -> Any:
         '''
         Do task execution
@@ -257,38 +244,42 @@ class BaseTask(
             return True
         self._is_keyval_set = True
         self.log_info('Set input map')
-        for task_input in self.get_all_inputs():
+        for task_input in self._get_combined_inputs():
             input_name = self._get_normalized_input_key(task_input.get_name())
             input_value = self.render_any(
                 kwargs.get(input_name, task_input.get_default())
             )
             self._set_input_map(input_name, input_value)
+        self._set_input_map('_execution_id', self._execution_id)
         self.log_debug(
             'Input map:\n' + map_to_str(self.get_input_map(), item_prefix='  ')
         )
         self.log_info('Merging task envs, task env files, and native envs')
-        for env_name, env in self._get_all_envs().items():
+        for env_name, env in self._get_combined_env().items():
             env_value = env.get(env_prefix)
             if env.renderable:
                 env_value = self.render_any(env_value)
             self._set_env_map(env_name, env_value)
+        self._set_env_map('_ZRB_EXECUTION_ID', self._execution_id)
         self.log_debug(
             'Env map:\n' + map_to_str(self.get_env_map(), item_prefix='  ')
         )
 
-    def _get_all_envs(self) -> Mapping[str, Env]:
-        self._allow_add_envs = False
-        self._allow_add_env_files = False
+    def _get_combined_env(self) -> Mapping[str, Env]:
         all_envs: Mapping[str, Env] = {}
         for env_name in os.environ:
+            if env_name in RESERVED_ENV_NAMES:
+                continue
             all_envs[env_name] = Env(
                 name=env_name, os_name=env_name, renderable=False
             )
-        for env_file in self._env_files:
+        for env_file in self._get_env_files():
             for env in env_file.get_envs():
                 all_envs[env.name] = env
-        for env in self._envs:
+        for env in self._get_envs():
             all_envs[env.name] = env
+        self._allow_add_envs = False
+        self._allow_add_env_files = False
         return all_envs
 
     def _get_normalized_input_key(self, key: str) -> str:
@@ -305,6 +296,10 @@ class BaseTask(
     ):
         try:
             self._start_timer()
+            if self.get_execution_id() == '':
+                self._set_execution_id(
+                    get_random_name(add_random_digit=True, digit_count=5)
+                )
             self.log_info('Set input and env map')
             await self._set_keyval(kwargs=kwargs, env_prefix=env_prefix)
             self.log_info('Set run kwargs')
@@ -342,9 +337,10 @@ class BaseTask(
             return
         if self._return_upstream_result:
             # if _return_upstream_result, result is list (see: self._run_all)
+            upstreams = self._get_upstreams()
             upstream_results = list(result)
             for upstream_index, upstream_result in enumerate(upstream_results):
-                self._upstreams[upstream_index]._print_result(upstream_result)
+                upstreams[upstream_index]._print_result(upstream_result)
             return
         self.print_result(result)
 
@@ -382,14 +378,14 @@ class BaseTask(
 
     def _show_run_command(self):
         params: List[str] = [double_quote(arg) for arg in self._args]
-        for task_input in self.get_all_inputs():
+        for task_input in self._get_combined_inputs():
             if task_input.is_hidden():
                 continue
             key = task_input.get_name()
             kwarg_key = self._get_normalized_input_key(key)
             quoted_value = double_quote(str(self._kwargs[kwarg_key]))
             params.append(f'--{key} {quoted_value}')
-        run_cmd = self.get_complete_cmd_name()
+        run_cmd = self.get_full_cmd_name()
         run_cmd_with_param = run_cmd
         if len(params) > 0:
             param_str = ' '.join(params)
@@ -426,6 +422,7 @@ class BaseTask(
             await asyncio.sleep(0.1)
         check_coroutines: Iterable[asyncio.Task] = []
         for checker_task in self._checkers:
+            checker_task._set_execution_id(self.get_execution_id())
             check_coroutines.append(
                 asyncio.create_task(checker_task._run_all())
             )
@@ -437,7 +434,8 @@ class BaseTask(
         coroutines: Iterable[asyncio.Task] = []
         # Add upstream tasks to processes
         self._allow_add_upstreams = False
-        for upstream_task in self._upstreams:
+        for upstream_task in self._get_upstreams():
+            upstream_task._set_execution_id(self.get_execution_id())
             coroutines.append(asyncio.create_task(
                 upstream_task._run_all(**kwargs)
             ))
@@ -459,7 +457,7 @@ class BaseTask(
         # get upstream checker
         upstream_check_processes: Iterable[asyncio.Task] = []
         self._allow_add_upstreams = False
-        for upstream_task in self._upstreams:
+        for upstream_task in self._get_upstreams():
             upstream_check_processes.append(asyncio.create_task(
                 upstream_task._loop_check()
             ))
@@ -503,7 +501,7 @@ class BaseTask(
 
     async def _set_keyval(self, kwargs: Mapping[str, Any], env_prefix: str):
         # if input is not in input_map, add default values
-        for task_input in self.get_all_inputs():
+        for task_input in self._get_combined_inputs():
             key = self._get_normalized_input_key(task_input.get_name())
             if key in kwargs:
                 continue
@@ -514,20 +512,20 @@ class BaseTask(
         new_kwargs = copy.deepcopy(kwargs)
         new_kwargs.update(self.get_input_map())
         upstream_coroutines = []
-        # set uplstreams keyval
+        # set upstreams keyval
         self._allow_add_upstreams = False
-        for upstream_task in self._upstreams:
+        for upstream_task in self._get_upstreams():
             upstream_coroutines.append(asyncio.create_task(
                 upstream_task._set_keyval(
                     kwargs=new_kwargs, env_prefix=env_prefix
                 )
             ))
         # set checker keyval
-        local_env_map = self.get_env_map()
+        # local_env_map = self.get_env_map()
         checker_coroutines = []
         for checker_task in self._checkers:
-            checker_task._inputs += self._inputs
-            checker_task.inject_env_map(local_env_map, override=True)
+            checker_task.add_input(*self._get_inputs())
+            checker_task.add_env(*self._get_envs())
             checker_coroutines.append(asyncio.create_task(
                 checker_task._set_keyval(
                     kwargs=new_kwargs, env_prefix=env_prefix

zrb/task/base_task_composite.py

@@ -66,6 +66,17 @@ class CommonTaskModel():
         self._allow_add_envs = True
         self._allow_add_env_files = True
         self._allow_add_inputs = True
+        self._allow_add_upstreams: bool = True
+        self._has_already_inject_env_files: bool = False
+        self._has_already_inject_envs: bool = False
+        self._has_already_inject_inputs: bool = False
+        self._has_already_inject_checkers: bool = False
+        self._has_already_inject_upstreams: bool = False
+        self._execution_id = ''
+
+    def _set_execution_id(self, execution_id: str):
+        if self._execution_id != '':
+            self._execution_id = execution_id
 
     def set_name(self, new_name: str):
         if self._description == self._name:
@@ -95,20 +106,48 @@ class CommonTaskModel():
     def set_checking_interval(self, new_checking_interval: Union[float, int]):
         self._checking_interval = new_checking_interval
 
-    def add_inputs(self, *inputs: AnyInput):
+    def insert_input(self, *inputs: AnyInput):
         if not self._allow_add_inputs:
-            raise Exception(f'Cannot add inputs on `{self._name}`')
-        self._inputs += inputs
+            raise Exception(f'Cannot insert inputs for `{self._name}`')
+        self._inputs = list(inputs) + list(self._inputs)
 
-    def add_envs(self, *envs: Env):
+    def add_input(self, *inputs: AnyInput):
+        if not self._allow_add_inputs:
+            raise Exception(f'Cannot add inputs for `{self._name}`')
+        self._inputs = list(self._inputs) + list(inputs)
+
+    def insert_env(self, *envs: Env):
+        if not self._allow_add_envs:
+            raise Exception(f'Cannot insert envs to `{self._name}`')
+        self._envs = list(envs) + list(self._envs)
+
+    def add_env(self, *envs: Env):
         if not self._allow_add_envs:
-            raise Exception(f'Cannot add envs on `{self._name}`')
-        self._envs += envs
+            raise Exception(f'Cannot add envs to `{self._name}`')
+        self._envs = list(self._envs) + list(envs)
 
-    def add_env_files(self, *env_files: EnvFile):
+    def insert_env_file(self, *env_files: EnvFile):
         if not self._allow_add_env_files:
-            raise Exception(f'Cannot add env_files on `{self._name}`')
-        self._env_files += env_files
+            raise Exception(f'Cannot insert env_files to `{self._name}`')
+        self._env_files = list(env_files) + list(self._env_files)
+
+    def add_env_file(self, *env_files: EnvFile):
+        if not self._allow_add_env_files:
+            raise Exception(f'Cannot add env_files to `{self._name}`')
+        self._env_files = list(self._env_files) + list(env_files)
+
+    def insert_upstream(self, *upstreams: AnyTask):
+        if not self._allow_add_upstreams:
+            raise Exception(f'Cannot insert upstreams to `{self._name}`')
+        self._upstreams = list(upstreams) + list(self._upstreams)
+
+    def add_upstream(self, *upstreams: AnyTask):
+        if not self._allow_add_upstreams:
+            raise Exception(f'Cannot add upstreams to `{self._name}`')
+        self._upstreams = list(self._upstreams) + list(upstreams)
+
+    def get_execution_id(self) -> str:
+        return self._execution_id
 
     def get_icon(self) -> str:
         return self._icon
@@ -116,20 +155,50 @@ class CommonTaskModel():
     def get_color(self) -> str:
         return self._color
 
-    def get_env_files(self) -> List[EnvFile]:
+    def inject_env_files(self):
+        pass
+
+    def _get_env_files(self) -> List[EnvFile]:
+        if not self._has_already_inject_env_files:
+            self.inject_env_files()
+            self._has_already_inject_env_files = True
         return self._env_files
 
-    def get_envs(self) -> List[Env]:
-        return self._envs
+    def inject_envs(self):
+        pass
+
+    def _get_envs(self) -> List[Env]:
+        if not self._has_already_inject_envs:
+            self.inject_envs()
+            self._has_already_inject_envs = True
+        return list(self._envs)
+
+    def inject_inputs(self):
+        pass
+
+    def _get_inputs(self) -> List[AnyInput]:
+        if not self._has_already_inject_inputs:
+            self.inject_inputs()
+            self._has_already_inject_inputs = True
+        return list(self._inputs)
+
+    def inject_checkers(self):
+        pass
 
-    def get_inputs(self) -> List[AnyInput]:
-        return self._inputs
+    def _get_checkers(self) -> List[AnyTask]:
+        if not self._has_already_inject_checkers:
+            self.inject_checkers()
+            self._has_already_inject_checkers = True
+        return list(self._checkers)
 
-    def get_checkers(self) -> Iterable[AnyTask]:
-        return self._checkers
+    def inject_upstreams(self):
+        pass
 
-    def get_upstreams(self) -> Iterable[AnyTask]:
-        return self._upstreams
+    def _get_upstreams(self) -> List[AnyTask]:
+        if not self._has_already_inject_upstreams:
+            self.inject_upstreams()
+            self._has_already_inject_upstreams = True
+        return list(self._upstreams)
 
     def get_description(self) -> str:
         return self._description
@@ -354,7 +423,7 @@ class TaskModelWithPrinterAndTracker(
         run: Optional[Callable[..., Any]] = None,
         should_execute: Union[bool, str, Callable[..., bool]] = True
     ):
-        self._filled_complete_name: Optional[str] = None
+        self._rjust_full_cmd_name: Optional[str] = None
         self._has_cli_interface = False
         self._complete_name: Optional[str] = None
         CommonTaskModel.__init__(
@@ -441,13 +510,13 @@ class TaskModelWithPrinterAndTracker(
     def _get_print_prefix(self) -> str:
         common_prefix = self._get_common_prefix(show_time=show_time)
         icon = self.get_icon()
-        truncated_name = self._get_filled_complete_name()
+        truncated_name = self._get_rjust_full_cmd_name()
         return f'{common_prefix} {icon} {truncated_name}'
 
     def _get_log_prefix(self) -> str:
         common_prefix = self._get_common_prefix(show_time=False)
         icon = self.get_icon()
-        filled_name = self._get_filled_complete_name()
+        filled_name = self._get_rjust_full_cmd_name()
         return f'{common_prefix} {icon} {filled_name}'
 
     def _get_common_prefix(self, show_time: bool) -> str:
@@ -459,14 +528,14 @@ class TaskModelWithPrinterAndTracker(
             return f'◷ {now} ❁ {pid} → {attempt}/{max_attempt}'
         return f'❁ {pid} → {attempt}/{max_attempt}'
 
-    def _get_filled_complete_name(self) -> str:
-        if self._filled_complete_name is not None:
-            return self._filled_complete_name
-        complete_name = self.get_complete_cmd_name()
-        self._filled_complete_name = complete_name.rjust(LOG_NAME_LENGTH, ' ')
-        return self._filled_complete_name
+    def _get_rjust_full_cmd_name(self) -> str:
+        if self._rjust_full_cmd_name is not None:
+            return self._rjust_full_cmd_name
+        complete_name = self.get_full_cmd_name()
+        self._rjust_full_cmd_name = complete_name.rjust(LOG_NAME_LENGTH, ' ')
+        return self._rjust_full_cmd_name
 
-    def get_complete_cmd_name(self) -> str:
+    def get_full_cmd_name(self) -> str:
         if self._complete_name is not None:
             return self._complete_name
         executable_prefix = ''

zrb/task/cmd_task.py

@@ -1,5 +1,5 @@
 from zrb.helper.typing import (
-    Any, Callable, Iterable, List, Mapping, Optional, Union, TypeVar
+    Any, Callable, Iterable, List, Optional, Union, TypeVar
 )
 from zrb.helper.typecheck import typechecked
 from zrb.task.any_task import AnyTask
@@ -182,18 +182,17 @@ class CmdTask(BaseTask):
             return
         print(result.output)
 
-    def _get_shell_env_map(self) -> Mapping[str, Any]:
-        env_map = self.get_env_map()
+    def inject_envs(self):
+        super().inject_envs()
         input_map = self.get_input_map()
         for input_name, input_value in input_map.items():
-            upper_input_name = '_INPUT_' + input_name.upper()
-            if upper_input_name not in env_map:
-                env_map[upper_input_name] = f'{input_value}'
-        return env_map
+            env_name = '_INPUT_' + input_name.upper()
+            self.add_env(
+                Env(name=env_name, os_name='', default=str(input_value))
+            )
 
     async def run(self, *args: Any, **kwargs: Any) -> CmdResult:
-        cmd = self._get_cmd_str(*args, **kwargs)
-        env_map = self._get_shell_env_map()
+        cmd = self.get_cmd_script(*args, **kwargs)
         self.print_out_dark('Run script: ' + self._get_multiline_repr(cmd))
         self.print_out_dark('Working directory: ' + self._cwd)
         self._output_buffer = []
@@ -203,7 +202,7 @@ class CmdTask(BaseTask):
             cwd=self._cwd,
             stdout=asyncio.subprocess.PIPE,
             stderr=asyncio.subprocess.PIPE,
-            env=env_map,
+            env=self.get_env_map(),
             shell=True,
             executable=self._executable,
             close_fds=True,
@@ -314,21 +313,25 @@ class CmdTask(BaseTask):
         await stdout_log_process
         await stderr_log_process
 
-    def _get_cmd_str(self, *args: Any, **kwargs: Any) -> str:
-        return self._create_cmd_str(self._cmd_path, self._cmd, *args, **kwargs)
+    def get_cmd_script(self, *args: Any, **kwargs: Any) -> str:
+        return self._create_cmd_script(
+            self._cmd_path, self._cmd, *args, **kwargs
+        )
 
-    def _create_cmd_str(
+    def _create_cmd_script(
         self, cmd_path: CmdVal, cmd: CmdVal, *args: Any, **kwargs: Any
     ) -> str:
         if not isinstance(cmd_path, str) or cmd_path != '':
             if callable(cmd_path):
-                return self._render_cmd_path_str(cmd_path(*args, **kwargs))
-            return self._render_cmd_path_str(cmd_path)
+                return self._get_rendered_cmd_path(cmd_path(*args, **kwargs))
+            return self._get_rendered_cmd_path(cmd_path)
         if callable(cmd):
-            return self._render_cmd_str(cmd(*args, **kwargs))
-        return self._render_cmd_str(cmd)
+            return self._get_rendered_cmd(cmd(*args, **kwargs))
+        return self._get_rendered_cmd(cmd)
 
-    def _render_cmd_path_str(self, cmd_path: Union[str, Iterable[str]]) -> str:
+    def _get_rendered_cmd_path(
+        self, cmd_path: Union[str, Iterable[str]]
+    ) -> str:
         if isinstance(cmd_path, str):
             return self.render_file(cmd_path)
         return '\n'.join([
@@ -336,7 +339,7 @@ class CmdTask(BaseTask):
             for cmd_path_str in cmd_path
         ])
 
-    def _render_cmd_str(self, cmd: Union[str, Iterable[str]]) -> str:
+    def _get_rendered_cmd(self, cmd: Union[str, Iterable[str]]) -> str:
         if isinstance(cmd, str):
             return self.render_str(cmd)
         return self.render_str('\n'.join(list(cmd)))

zrb/task/docker_compose_task.py

@@ -7,6 +7,7 @@ from zrb.task.any_task import AnyTask
 from zrb.task.any_task_event_handler import (
     OnTriggered, OnWaiting, OnSkipped, OnStarted, OnReady, OnRetry, OnFailed
 )
+from zrb.task_env.constant import RESERVED_ENV_NAMES
 from zrb.task_env.env import Env
 from zrb.task_env.env_file import EnvFile
 from zrb.task_group.group import Group
@@ -152,7 +153,8 @@ class DockerComposeTask(CmdTask):
         )
         # Flag to make mark whether service config and compose environments
         # has been added to this task's envs and env_files
-        self._is_additional_env_added = False
+        self._is_compose_additional_env_added = False
+        self._is_compose_additional_env_file_added = False
 
     def copy(self) -> TDockerComposeTask:
         return super().copy()
@@ -165,45 +167,30 @@ class DockerComposeTask(CmdTask):
             os.remove(self._compose_runtime_file)
         return result
 
-    def _get_all_envs(self) -> Mapping[str, Env]:
-        '''
-        This method override BaseTask's _get_all_envs.
-        Whenever _get_all_envs is called, we want to make sure that:
-        - Service config's envs and env_files are included
-        - Any environment defined in docker compose file is also included
-        '''
-        if self._is_additional_env_added:
-            return super()._get_all_envs()
-        self._is_additional_env_added = True
-        # define additional envs and additonal env_files
-        additional_envs: List[Env] = []
-        additional_env_files: List[EnvFile] = []
-        # populate additional envs and additional env_files
-        # with service configs
+    def inject_envs(self):
+        super().inject_envs()
+        # inject envs from service_configs
         for _, service_config in self._compose_service_configs.items():
-            additional_env_files += service_config.get_env_files()
-            additional_envs += service_config.get_envs()
-        # populate additional envs and additional env_files with
-        # compose envs
-        data = read_compose_file(self._compose_template_file)
-        env_map = fetch_compose_file_env_map(data)
-        registered_env_map: Mapping[str, bool] = {}
+            self.insert_env(*service_config.get_envs())
+        # inject envs from docker compose file
+        compose_data = read_compose_file(self._compose_template_file)
+        env_map = fetch_compose_file_env_map(compose_data)
+        added_env_map: Mapping[str, bool] = {}
         for key, value in env_map.items():
             # Need to get this everytime because we only want
             # the first compose file env value for a certain key
-            if key in registered_env_map:
+            if key in RESERVED_ENV_NAMES or key in added_env_map:
                 continue
+            added_env_map[key] = True
             os_name = key
             if self._compose_env_prefix != '':
                 os_name = f'{self._compose_env_prefix}_{os_name}'
-            compose_env = Env(name=key, os_name=os_name, default=value)
-            additional_envs.append(compose_env)
-            registered_env_map[key] = True
-        # Add additional envs and addition env files to this task
-        self._envs = additional_envs + list(self._envs)
-        self._env_files = additional_env_files + list(self._env_files)
-        # get all envs
-        return super()._get_all_envs()
+            self.insert_env(Env(name=key, os_name=os_name, default=value))
+
+    def inject_env_files(self):
+        # inject env_files from service_configs
+        for _, service_config in self._compose_service_configs.items():
+            self.insert_env_file(*service_config.get_env_files())
 
     def _generate_compose_runtime_file(self):
         compose_data = read_compose_file(self._compose_template_file)
@@ -310,8 +297,8 @@ class DockerComposeTask(CmdTask):
             return os.path.join(self._cwd, compose_file)
         raise Exception(f'Invalid compose file: {compose_file}')
 
-    def _get_cmd_str(self, *args: Any, **kwargs: Any) -> str:
-        setup_cmd_str = self._create_cmd_str(
+    def get_cmd_script(self, *args: Any, **kwargs: Any) -> str:
+        setup_cmd_str = self._create_cmd_script(
             self._setup_cmd_path, self._setup_cmd, *args, **kwargs
         )
         command_options = dict(self._compose_options)

zrb/task/flow_task.py

@@ -107,10 +107,10 @@ class FlowTask(BaseTask):
         embeded_tasks: List[AnyTask] = []
         for task in tasks:
             embeded_task = task.copy()
-            embeded_task.add_upstreams(*upstreams)
-            embeded_task.add_envs(*envs)
-            embeded_task.add_env_files(*env_files)
-            embeded_task.add_inputs(*inputs)
+            embeded_task.add_upstream(*upstreams)
+            embeded_task.add_env(*envs)
+            embeded_task.add_env_file(*env_files)
+            embeded_task.add_input(*inputs)
             embeded_tasks.append(embeded_task)
         return embeded_tasks
 

zrb/task_env/constant.py

@@ -0,0 +1 @@
+RESERVED_ENV_NAMES = ('_ZRB_EXECUTION_ID',)

zrb/task_env/env.py

@@ -1,5 +1,6 @@
 from zrb.helper.typing import Optional
 from zrb.helper.typecheck import typechecked
+from zrb.task_env.constant import RESERVED_ENV_NAMES
 import os
 
 
@@ -16,6 +17,8 @@ class Env():
         default: str = '',
         renderable: bool = True,
     ):
+        if name in RESERVED_ENV_NAMES:
+            raise ValueError(f'Forbidden input name: {name}')
         self.name: str = name
         self.os_name: str = os_name if os_name is not None else name
         self.default: str = default

zrb/task_env/env_file.py

@@ -1,6 +1,7 @@
 from zrb.helper.typing import List, Optional
 from zrb.helper.typecheck import typechecked
 from dotenv import dotenv_values
+from zrb.task_env.constant import RESERVED_ENV_NAMES
 from zrb.task_env.env import Env
 
 
@@ -25,6 +26,8 @@ class EnvFile():
         env_list: List[Env] = []
         env_map = dotenv_values(self.env_file)
         for key, value in env_map.items():
+            if key in RESERVED_ENV_NAMES:
+                continue
             os_name: Optional[str] = None
             if self.prefix is not None and self.prefix != '':
                 os_name = f'{self.prefix}_{key}'

zrb/task_input/constant.py

@@ -1 +1 @@
-RESERVED_INPUT_NAMES = ('_task', '_args')
+RESERVED_INPUT_NAMES = ('_task', '_args', '_execution_id')

{zrb-0.0.108.dist-info → zrb-0.0.110.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zrb
-Version: 0.0.108
+Version: 0.0.110
 Summary: Super framework for your super app
 Author-email: Go Frendi Gunawan <gofrendiasgard@gmail.com>
 Requires-Python: >=3.10.0
@@ -30,9 +30,9 @@ Provides-Extra: test
 
 # 🤖 Zrb (Read: Zaruba) : A Super Framework for Your Super App
 
-![](https://raw.githubusercontent.com/state-alchemists/zrb/main/images/zrb/android-chrome-192x192.png)
+![](https://raw.githubusercontent.com/state-alchemists/zrb/main/_images/zrb/android-chrome-192x192.png)
 
-[📖 Documentation](https://github.com/state-alchemists/zrb/blob/main/docs/README.md) | [🏁 Getting Started](https://github.com/state-alchemists/zrb/blob/main/docs/getting-started.md) | [💃 Oops, I did it Again](https://github.com/state-alchemists/zrb/blob/main/docs/oops-i-did-it-again/README.md)| [❓ FAQ](https://github.com/state-alchemists/zrb/blob/main/docs/faq/README.md)
+[📖 Documentation](https://github.com/state-alchemists/zrb/blob/main/docs/README.md) | [🏁 Getting Started](https://github.com/state-alchemists/zrb/blob/main/docs/getting-started.md) | [💃 Oops, I did it Again](https://github.com/state-alchemists/zrb/blob/main/docs/oops-i-did-it-again/README.md) | [❓ FAQ](https://github.com/state-alchemists/zrb/blob/main/docs/faq/README.md)
 
 Zrb is a [CLI-based](https://en.wikipedia.org/wiki/Command-line_interface) automation [tool](https://en.wikipedia.org/wiki/Programming_tool) and [low-code](https://en.wikipedia.org/wiki/Low-code_development_platform) platform. Once installed, Zrb will help you automate day-to-day tasks, generate projects and applications, and even deploy your applications to Kubernetes with a few commands.
 
@@ -40,7 +40,7 @@ To use Zrb, you need to be familiar with CLI.
 
 Zrb task definitions are written in [Python](https://www.python.org/), and we have a [very good reason](https://github.com/state-alchemists/zrb/blob/main/docs/faq/why-python.md) behind the decision.
 
-## Zrb as a low-code framework
+## Zrb is A Low-Code Framework
 
 Let's see how you can build and run a [CRUD](https://en.wikipedia.org/wiki/Create,_read,_update_and_delete) application.
 
@@ -69,9 +69,9 @@ zrb project start-fastapp --fastapp-run-mode "monolith"
 
 You will be able to access the application by pointing your browser to [http://localhost:3000](http://localhost:3000)
 
-![](https://raw.githubusercontent.com/state-alchemists/zrb/main/images/fastapp.png)
+![](https://raw.githubusercontent.com/state-alchemists/zrb/main/_images/fastapp.png)
 
-Furthermore, you can also run the same application as `microservices`, run the application as `docker containers`, and even doing some deployments into your `kubernetes cluster`.
+Furthermore, you can run the same application as `microservices`, run the application as `docker containers`, and even do some deployments into your `kubernetes cluster`.
 
 
 ```bash
@@ -90,9 +90,9 @@ zrb project deploy-fastapp --fastapp-deploy-mode "microservices"
 You can visit [our tutorials](https://github.com/state-alchemists/zrb/blob/main/docs/tutorials/README.md) to see more cool tricks.
 
 
-## Zrb as a task-automation framework
+## Zrb is A Task-Automation Tool
 
-Aside from the builtin capabilities, Zrb also allows you to define your automation commands in Python. To do so, you need to create/modify a file named `zrb_init.py`.
+Aside from the built-in capabilities, Zrb also allows you to define your automation commands in Python. To do so, you must create/modify a file named `zrb_init.py`.
 
 ```python
 # filename: zrb_init.py
@@ -133,7 +133,7 @@ To learn more about this, you can visit [our getting started guide](https://gith
 
 # 🫰 Installation
 
-## ⚙️ In local machine
+## ⚙️ In Local Machine
 
 Installing Zrb in your system is as easy as typing the following command in your terminal:
 
@@ -141,11 +141,11 @@ Installing Zrb in your system is as easy as typing the following command in your
 pip install zrb
 ```
 
-Just like any other Python package, you can also install Zrb in your [virtual environment](https://docs.python.org/3/library/venv.html). This will allow you to have many versions of Zrb on the same computer.
+Like any other Python package, you can install Zrb in your [virtual environment](https://docs.python.org/3/library/venv.html). This will allow you to have many versions of Zrb on the same computer.
 
 > ⚠️ If the command doesn't work, you probably don't have Pip/Python on your computer. See `Main prerequisites` subsection to install them.
 
-## 🐋 With docker
+## 🐋 With Docker
 
 If you prefer to work with Docker, you can create a file named `docker-compose.yml`
 
@@ -184,7 +184,7 @@ You will be able to access Zrb by using docker exec:
 docker exec -it zrb zsh
 ```
 
-# ✅ Main prerequisites
+# ✅ Main Prerequisites
 
 Since Zrb is written in Python, you need to install a few things before installing Zrb:
 
@@ -209,11 +209,11 @@ ln -s venv/bin/python3 /usr/local/bin/python
 
 If you prefer Python distribution like [conda](https://docs.conda.io/en/latest/), that might work as well.
 
-# ✔️ Other prerequisites
+# ✔️ Other Prerequisites
 
 If you want to generate applications using Zrb and run them on your computer, you will also need:
 
-- 🐸 `Node.Js` and `Npm`. 
+- 🐸 `Node.Js` and `Npm`.
     - You need Node.Js to modify/transpile frontend code into static files.
     - You can visit the [Node.Js website](https://nodejs.org/en) for installation instructions.
 - 🐋 `Docker` and `Docker-compose` plugin.
@@ -228,9 +228,9 @@ If you want to generate applications using Zrb and run them on your computer, yo
 - 🦆 `Pulumi`
     - You need Pulumi to deploy your applications
 
-# 🏁 Getting started
+# 🏁 Getting Started
 
-We have a nice [getting started guide](https://github.com/state-alchemists/zrb/blob/main/docs/getting-started.md) to help you cover the basics. Make sure to check it out😉.
+We have an excellent [getting started guide](https://github.com/state-alchemists/zrb/blob/main/docs/getting-started.md) to help you cover the basics. Make sure to check it out😉.
 
 # 📖 Documentation
 
@@ -240,11 +240,11 @@ You can visit [Zrb documentation](https://github.com/state-alchemists/zrb/blob/m
 
 Help Red Skull to click the donation button:
 
-[![](https://raw.githubusercontent.com/state-alchemists/zrb/main/images/donator.png)](https://stalchmst.com/donation)
+[![](https://raw.githubusercontent.com/state-alchemists/zrb/main/_images/donator.png)](https://stalchmst.com/donation)
 
-# 🎉 Fun fact
+# 🎉 Fun Fact
 
 > Madou Ring Zaruba (魔導輪ザルバ, Madōrin Zaruba) is a Madougu which supports bearers of the Garo Armor. [(Garo Wiki | Fandom)](https://garo.fandom.com/wiki/Zaruba)
 
-![Madou Ring Zaruba on Kouga's Hand](https://raw.githubusercontent.com/state-alchemists/zrb/main/images/madou-ring-zaruba.jpg)
+![Madou Ring Zaruba on Kouga's Hand](https://raw.githubusercontent.com/state-alchemists/zrb/main/_images/madou-ring-zaruba.jpg)
 

{zrb-0.0.108.dist-info → zrb-0.0.110.dist-info}/RECORD

@@ -3,13 +3,13 @@ zrb/__main__.py,sha256=CdfuYSxqlJhnsJPOBOL2_uzEaTZHC3MtpyTuz8QUfUI,314
 zrb/advertisement.py,sha256=e-1tFPlmEuz8IqaIJ_9-2p9x5cuGsxssJGu5F0wHthI,505
 zrb/runner.py,sha256=MPCNPMCyiYNZeubSxd1eM2Zr6PCIKF-9pkG385AXElw,118
 zrb/action/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-zrb/action/runner.py,sha256=-bDR_dmsgKO_enhJ7xPE83MhU7-xpakxUtfNgNXdw-U,4474
+zrb/action/runner.py,sha256=JPWERMBRS7FW9Z1m1P2pI0farvdmA6fwX9NyZGJr6Dg,4476
 zrb/builtin/__init__.py,sha256=VpmpsDJmL2Qe1MDiVTaGgGgW9MxRz8sR21Blclg6MDE,580
 zrb/builtin/base64.py,sha256=_Ff8eQi0pMa4qqDUqZqA-u-2LpSA5s3AN0Nj2M7ibnQ,1318
 zrb/builtin/env.py,sha256=hEjQios0i-3DantczxQnZnolzwZAGIQOE0Ygka330EU,1146
 zrb/builtin/eval.py,sha256=FjAeWuD6KdvSKwsoUo8qbSO9qgc0rQVmRNib-XKOfVc,745
 zrb/builtin/explain.py,sha256=ee2UjBS-J5-Hf9JDEQR_vs056NiMZCCHtLvE_rrW4AU,5377
-zrb/builtin/git.py,sha256=Lz9AFQBr3YEyIO-nuCdeYmNjxq8LVpB-PHE9Kj1lBjg,2679
+zrb/builtin/git.py,sha256=VIhXv8LV12vysSJYitW26mU5p6x9bmTCYknAM4Qu1h0,2616
 zrb/builtin/group.py,sha256=ncUsZcGRUF9QKNMt-_1zDNDi4Z2KA5jpjwEuYIzhKmo,1077
 zrb/builtin/md5.py,sha256=IWN0uroXRiuyF0wD05BzGqAkMA3p6q9EbtWmJOPdOc0,1376
 zrb/builtin/process.py,sha256=h7uMfEIqbOaNe8aTINZYYbHWw7mmUF8DkeiylPeWzSE,1281
@@ -1102,7 +1102,7 @@ zrb/helper/util.py,sha256=82LBcWV8vAnMnYYIfnKq27EfaY_ATxLNJpcePe7VwQI,3469
 zrb/helper/accessories/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/helper/accessories/color.py,sha256=2G_Ys_iFF7hnnbeLqO3YRBGiYdxnduk0CMcyz4Y8dgg,709
 zrb/helper/accessories/icon.py,sha256=hCL8tSvxxRy7PTKQXsvS4oTPyrP87Zn5RoBgsCq-NLs,347
-zrb/helper/accessories/name.py,sha256=QnZ8dzIaYfxWnS_iOXUlSt497ly4Tw5MsAevYerEerg,1271
+zrb/helper/accessories/name.py,sha256=DoSTf6SjWOP0GEzWvIalcJeuft8C19v09vfJ1MotTuE,2043
 zrb/helper/codemod/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/helper/codemod/add_argument_to_function.py,sha256=5tuDqcMMozANchrHuUspH5MlRdQj5nw_mwhCzEXb0qY,1265
 zrb/helper/codemod/add_argument_to_function_call.py,sha256=aqQxpmbFbtejJPdjG7v1QIwsaBUT0v_M9ZGhTSxIFKU,1041
@@ -1117,7 +1117,7 @@ zrb/helper/codemod/format_code.py,sha256=ymxZtZm-5RuaddLUu8LJgguX0n8CJSbHb-McQDU
 zrb/helper/docker_compose/fetch_external_env.py,sha256=pIXkMCXtDXVWdNPlpMolqdj4Q0Y73dhCeqwByCB6mWg,2042
 zrb/helper/docker_compose/file.py,sha256=aBtQMV57TWtMO9AwsZ2OyBn16MhElZaDlq54zBqYBnA,685
 zrb/helper/env_map/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-zrb/helper/env_map/fetch.py,sha256=7Oh1BUn71D5QS1BKftqIwopCowjffe2vrDmH3w3oZkg,2160
+zrb/helper/env_map/fetch.py,sha256=Nl243-dcIEpbImAveZAXo2l0IGNXxD5RN_CyxGYTZeo,2173
 zrb/helper/file/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/helper/file/copy_tree.py,sha256=4kVqupzLYyF_neiRsedAFbxkeiK0VYsW45Z2zCkWLXA,1804
 zrb/helper/file/text.py,sha256=_S1uYToMw3lcI95-op_kM_SWNJUyvYNc32XHIcokDWU,807
@@ -1137,18 +1137,18 @@ zrb/shell-scripts/_common-util.sh,sha256=6WPPOp_NBUgIMd1K2qlVZ6iYzZ-Xl3lUTzi4Rqr
 zrb/shell-scripts/ensure-docker-is-installed.sh,sha256=CpfGjfoXFXoTWXsONIGZCMnmtFrk6ZamvO_8Fqp_WJ0,2893
 zrb/shell-scripts/ensure-rsync-is-installed.sh,sha256=vHJWNEidemIrM2tQ17r5qwSUjz9hVKcjYbUEMo3pPJI,987
 zrb/shell-scripts/ensure-ssh-is-installed.sh,sha256=TM0PLXT2vNfgv2ffcW_l-IqtMqHI1Z9nGdJvlToUlyM,2092
-zrb/shell-scripts/rsync-util.sh,sha256=E4Of-AugCFKabQvk-mC0RrQ4JexS7JLT5p6Ux92ETcY,326
+zrb/shell-scripts/rsync-util.sh,sha256=QzdhSBvUNMxB4U2B4m0Dxg9czGckRjB7Vk4A1ObG0-k,353
 zrb/shell-scripts/ssh-util.sh,sha256=9lXDzw6oO8HuA4vdbfps_uQMMwKyNYX9fZkZgpK52g8,401
 zrb/task/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-zrb/task/any_task.py,sha256=bG4nVYmEqsf3Kbl78RjIAEv1YHUArpWGMXKiOzIkXa4,5646
+zrb/task/any_task.py,sha256=fViLjv35ZAuQxBjArv52E6LJgv9vvgihCGEPuiEgv_4,6238
 zrb/task/any_task_event_handler.py,sha256=vpO9t0fck8-oFu1KYptfcg2hXKRsk6V5je4Dg-Bl21o,359
-zrb/task/base_remote_cmd_task.py,sha256=mRizRbkvZwWeBU_MO7qiF89co5Y30ICpxD7cwbpRN3Y,8033
-zrb/task/base_task.py,sha256=yuKfsPzIDHNFd5AUjr9rCStUryHYA_N-R-abJ5c8S38,20878
-zrb/task/base_task_composite.py,sha256=lpckzR6CWmjrGheSBnR1127DTYxk_iqGOPS72bz5F0U,16099
-zrb/task/cmd_task.py,sha256=zpoLkwt77PPeVc1YZCzjq1Kg4jUZ84OR6TpVPK166CM,12804
+zrb/task/base_remote_cmd_task.py,sha256=M0915WLSjokKrfdLdPhEtXRPKTG1BfWMRTQLEzj6hL4,8930
+zrb/task/base_task.py,sha256=HxMUb1Iqe4lLOkoSwxCNmRCk2ZE5FoYXmtW8IDy9DkY,21068
+zrb/task/base_task_composite.py,sha256=mkw6lSYnDqtO5a9y6HGfCWwBcQOfCx-gX8l0-DurC4Q,18756
+zrb/task/cmd_task.py,sha256=g96LPvWNoYoqGuo4V7ZrzGk8_witf4J0eIKMInwIjvM,12758
 zrb/task/decorator.py,sha256=6mJuDhmyHnVwx8SzBf8el5KwYJdA06VTeb1BABgLmTc,2399
-zrb/task/docker_compose_task.py,sha256=crvPId3c5hJ0kub1pg1DuQigzvMehYva3APRA_jg3HE,13785
-zrb/task/flow_task.py,sha256=w5MaHCQ5KGyongjLo6YjLy9GYM0rTF6yEBGQ4GqbRp0,3933
+zrb/task/docker_compose_task.py,sha256=aytg_c2_gDyhCIRxGmJONicz_Gw8QPVKWdFCV8rOngI,13152
+zrb/task/flow_task.py,sha256=lagR8S2tM3y7k5GFoo6qhr9rLJHGCjvVciwMMRxhpzg,3929
 zrb/task/http_checker.py,sha256=ajsBDRgpp2OMeLlgyCL15UECYr2SoKAWfU3PGOJY24Q,5519
 zrb/task/path_checker.py,sha256=EhPJHDPYGAJG3XPUaiN_iN9Y-vtf96gEsWwqagy4IIM,3879
 zrb/task/port_checker.py,sha256=bZ7JPSNoZ1zyZsS05tL4y7soKRbjyU0u3LXsPOE5w7I,4398
@@ -1156,8 +1156,9 @@ zrb/task/remote_cmd_task.py,sha256=LYWmnZ4mPsU-RIdAUyhui7mlIunx4vY8upwjhctnkEs,3
 zrb/task/resource_maker.py,sha256=QwB4S7aFjxX52onCqIu5OOMnm5omoZBl6OqZz9TqSOs,6379
 zrb/task/rsync_task.py,sha256=3vxENH-unD1VLgZI09Ts_lAQRMi2i1UiJpsaI1dltzI,3966
 zrb/task/task.py,sha256=aOwBVPl3U_dXCMcnrtcN0wPR8cDKbYkzgwa86BZMqBE,236
-zrb/task_env/env.py,sha256=1m1GUK4RhdCRfKtEfuCazppQceVAIO05UhJ5Xp-0FOk,1800
-zrb/task_env/env_file.py,sha256=Ku7WnPu-IkWi0fdjjXjTEvleYHfXO5v-g-0RUO2vVk4,1359
+zrb/task_env/constant.py,sha256=JdPhtZCTZlbW-jzG5vyFtpEXgTJ-Yx863LcrX_LiURY,44
+zrb/task_env/env.py,sha256=4oS4Y6_qwbzFqO08fzLb0TcSDAe9kxCW5cmbOFO1PSs,1954
+zrb/task_env/env_file.py,sha256=wQQmIQeK8-bRyl3KYe1xSFfebgHVFjXoXm8mQoVk7dY,1479
 zrb/task_group/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/task_group/group.py,sha256=qPZ79UZzLh5UPqsu2NflE6QAQzV568OPtXHcWloZX1o,1420
 zrb/task_input/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -1165,14 +1166,14 @@ zrb/task_input/any_input.py,sha256=pLHMnH8VteIXS1ZBuBAVz8_WlAcikTUk1WyU_EEXxX4,5
 zrb/task_input/base_input.py,sha256=98z4bQDvgKlhf8CFMtakbWjvFwn_Y4XKb4YdSB-OTwE,3144
 zrb/task_input/bool_input.py,sha256=8-Kc4Rdc1dykMHxGUuAnRdnRcyEYfVM8ECtZqT071Fc,1594
 zrb/task_input/choice_input.py,sha256=V7BvsI-cI1CCX1DrQQY9bvwEHBYfNvS1WW5QWreMF_0,1672
-zrb/task_input/constant.py,sha256=yvYY-Cc5eRAUQbe5aJcVVy846yyQYYg7v1hgiFyNikg,42
+zrb/task_input/constant.py,sha256=QgG5alvaRVQYQ5yFNEwj_1DvSmebW0xEDU1JXktSlO4,59
 zrb/task_input/float_input.py,sha256=flaZvFY55us8vtYuBxuAvvr4mTTAVZ-S8uTUt9AGfNg,1595
 zrb/task_input/int_input.py,sha256=mtNrgs65SL0GCzW5qr6c869UjiJ__zJaiXmJZCaqIJs,1592
 zrb/task_input/password_input.py,sha256=5bkUWyPumryigIy-S_z3nBDCo8sQB8_5PeS_gvPI0HQ,1611
 zrb/task_input/str_input.py,sha256=7cubJJKLCWRoGIRIM0_0WUhya18wvURoytrhVZA4xYI,1592
 zrb/task_input/task_input.py,sha256=HotqM1iYSzwE4PIj8grnEUsvJqjx1dS6Ek7i6ZJLq2Y,83
-zrb-0.0.108.dist-info/entry_points.txt,sha256=xTgXc1kBKYhJHEujdaSPHUcJT3-hbyP1mLgwkv-5sSk,40
-zrb-0.0.108.dist-info/LICENSE,sha256=WfnGCl8G60EYOPAEkuc8C9m9pdXWDe08NsKj3TBbxsM,728
-zrb-0.0.108.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
-zrb-0.0.108.dist-info/METADATA,sha256=6y-CGLAw5EcdsecZEIUXHvoAAKMOkedsEg1rNZaEjCk,9755
-zrb-0.0.108.dist-info/RECORD,,
+zrb-0.0.110.dist-info/entry_points.txt,sha256=xTgXc1kBKYhJHEujdaSPHUcJT3-hbyP1mLgwkv-5sSk,40
+zrb-0.0.110.dist-info/LICENSE,sha256=WfnGCl8G60EYOPAEkuc8C9m9pdXWDe08NsKj3TBbxsM,728
+zrb-0.0.110.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
+zrb-0.0.110.dist-info/METADATA,sha256=YIIg3sAs_V0P_U2aFDdowyznVCsNB1CAdt04_erUeBA,9740
+zrb-0.0.110.dist-info/RECORD,,