zrb 0.9.2__py3-none-any.whl → 0.10.0__py3-none-any.whl

zrb/helper/accessories/name.py

@@ -9,124 +9,68 @@ def get_random_name(
     separator: str = "-", add_random_digit: bool = True, digit_count: int = 4
 ) -> str:
     prefixes = [
-        "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",
+        "bold",
+        "calm",
+        "dark",
+        "deep",
+        "fast",
+        "firm",
+        "glad",
+        "grey",
+        "hard",
+        "high",
+        "kind",
+        "late",
+        "lean",
+        "long",
+        "loud",
+        "mild",
+        "neat",
+        "pure",
+        "rare",
+        "rich",
+        "safe",
+        "slow",
+        "soft",
+        "tall",
+        "thin",
+        "trim",
+        "vast",
+        "warm",
+        "weak",
+        "wild",
     ]
     suffixes = [
-        "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",
+        "arch",
+        "area",
+        "atom",
+        "base",
+        "beam",
+        "bell",
+        "bolt",
+        "bone",
+        "bulk",
+        "bush",
+        "cell",
+        "chip",
+        "clay",
+        "coal",
+        "coil",
+        "cone",
+        "cube",
+        "disk",
+        "dust",
+        "face",
+        "film",
+        "foam",
+        "frog",
+        "fuel",
+        "gate",
+        "gear",
+        "hall",
+        "hand",
+        "horn",
+        "leaf",
     ]
     prefix = random.choice(prefixes)
     suffix = random.choice(suffixes)

zrb/helper/codemod/add_property_to_class.py

@@ -65,7 +65,7 @@ def add_property_to_class(
 ) -> str:
     module = cst.parse_module(code)
     property_name_node = cst.Name(value=property_name)
-    property_type_node = cst.Annotation(cst.Name(value=property_type))
+    property_type_node = _get_property_type_node(property_type)
     property_value_node = _get_property_value_node(property_value)
     transformed_module = module.visit(
         AddPropertyTransformer(
@@ -78,6 +78,23 @@ def add_property_to_class(
     return transformed_module.code
 
 
+def _get_property_type_node(property_type: str) -> cst.Annotation:
+    if property_type.startswith("Optional[") and property_type.endswith("]"):
+        inner_type = property_type[len("Optional[") : -1]
+        return cst.Annotation(
+            annotation=cst.Subscript(
+                value=cst.Name("Optional"),
+                slice=[
+                    cst.SubscriptElement(
+                        slice=cst.Index(value=cst.Name(value=inner_type))
+                    )
+                ],
+            )
+        )
+    else:
+        return cst.Annotation(cst.Name(value=property_type))
+
+
 def _get_property_value_node(
     property_value: Optional[str],
 ) -> Optional[cst.BaseExpression]:

zrb/shell-scripts/ensure-podman-is-installed.sh

@@ -0,0 +1,55 @@
+set -e
+if command_exists podman
+then
+    log_info "Podman is already installed."
+else
+    log_info "Installing Podman..."
+    if [ "$OS_TYPE" = "Darwin" ]
+    then
+        if command_exists brew
+        then
+            brew install --cask podman
+            log_info "Please start Podman before proceeding."
+        else
+            log_info "Homebrew not found. Please install Homebrew and try again."
+            exit 1
+        fi
+    elif [ "$OS_TYPE" = "Linux" ]
+    then
+        if command_exists apt
+        then
+            try_sudo apt update
+            try_sudo apt install -y podman
+        elif command_exists yum
+        then
+            try_sudo yum install -y podman
+        elif command_exists dnf
+        then
+            try_sudo dnf install -y podman
+        elif command_exists pacman
+        then
+            try_sudo pacman -Syu --noconfirm podman
+        else
+            log_info "No known package manager found. Please install Podman manually."
+            exit 1
+        fi
+    else
+        log_info "Unsupported OS type. Please install Podman manually."
+        exit 1
+    fi
+fi
+
+if ! command_exists podman-compose
+then
+    log_info "Installing Podman Compose plugin..."
+    pip install podman-compose
+fi
+
+# Check Podman Compose plugin installation
+if command_exists podman && command_exists podman-compose
+then
+    log_info "Podman Compose plugin is already installed."
+else
+    log_info "Podman Compose plugin is not installed or podman is not running. Please check your installation."
+    exit 1
+fi

zrb/task/any_task.py

@@ -384,6 +384,44 @@ class AnyTask(ABC):
         """
         pass
 
+    @abstractmethod
+    def insert_fallback(self, *fallbacks: TAnyTask):
+        """
+        Inserts one or more `AnyTask` instances at the beginning of the current task's fallback list.
+
+        This method is used to define dependencies for the current task. Tasks in the fallback list are executed when the task is failed.
+        Adding a task to the beginning of the list means it will be
+        executed earlier than those already in the list.
+
+        Args:
+            fallbacks (TAnyTask): One or more task instances to be added to the fallback list.
+
+        Examples:
+            >>> from zrb import Task
+            >>> task = Task(name='task')
+            >>> fallback_task = Task(name='fallback-task')
+            >>> task.insert_fallback(fallback_task)
+        """
+        pass
+
+    @abstractmethod
+    def add_fallback(self, *fallbacks: TAnyTask):
+        """
+        Adds one or more `AnyTask` instances to the end of the current task's fallback list.
+
+        This method appends tasks to the fallback list, indicating that these tasks should be executed when the task is failed.
+
+        Args:
+            fallbacks (TAnyTask): One or more task instances to be added to the fallback list.
+
+        Examples:
+            >>> from zrb import Task
+            >>> task = Task(name='task')
+            >>> fallback_task = Task(name='fallback-task')
+            >>> task.add_fallback(fallback_task)
+        """
+        pass
+
     @abstractmethod
     def add_upstream(self, *upstreams: TAnyTask):
         """
@@ -519,6 +557,20 @@ class AnyTask(ABC):
         """
         pass
 
+    @abstractmethod
+    def _lock_upstreams(self):
+        """
+        Lock upstreams so that it cannot be altered anymore
+        """
+        pass
+
+    @abstractmethod
+    def _lock_fallbacks(self):
+        """
+        Lock fallbacks so that it cannot be altered anymore
+        """
+        pass
+
     @abstractmethod
     def _set_execution_id(self, execution_id: str):
         """
@@ -885,6 +937,37 @@ class AnyTask(ABC):
         """
         pass
 
+    @abstractmethod
+    def inject_fallbacks(self):
+        """
+        Injects fallback tasks into the current task.
+
+        This method is used for programmatically adding fallback to the task.
+        fallback tasks are those that must be completed when the task is failed.
+        Override this method in subclasses to specify such dependencies.
+
+        Examples:
+            >>> from zrb import Task
+            >>> class MyTask(Task):
+            >>>     def inject_fallbacks(self):
+            >>>         self.add_fallback(another_task)
+        """
+        pass
+
+    @abstractmethod
+    def _get_fallbacks(self) -> Iterable[TAnyTask]:
+        """
+        Retrieves the fallback tasks of the current task.
+
+        An internal method to get the list of fallback tasks that have been set for the
+        task, either statically or through `inject_fallbacks`. This is essential for task
+        fallback scenario.
+
+        Returns:
+            Iterable[TAnyTask]: An iterable of fallback tasks.
+        """
+        pass
+
     @abstractmethod
     def _get_combined_inputs(self) -> Iterable[AnyInput]:
         """

zrb/task/base_remote_cmd_task.py

@@ -78,6 +78,7 @@ class SingleBaseRemoteCmdTask(CmdTask):
         post_cmd_path: CmdVal = "",
         cwd: Optional[Union[str, pathlib.Path]] = None,
         upstreams: Iterable[AnyTask] = [],
+        fallbacks: Iterable[AnyTask] = [],
         on_triggered: Optional[OnTriggered] = None,
         on_waiting: Optional[OnWaiting] = None,
         on_skipped: Optional[OnSkipped] = None,
@@ -110,6 +111,7 @@ class SingleBaseRemoteCmdTask(CmdTask):
             cmd_path=cmd_path,
             cwd=cwd,
             upstreams=upstreams,
+            fallbacks=fallbacks,
             on_triggered=on_triggered,
             on_waiting=on_waiting,
             on_skipped=on_skipped,

zrb/task/base_task/base_task.py

@@ -39,6 +39,7 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
     """
 
     __xcom: Mapping[str, Mapping[str, str]] = {}
+    __running_tasks: List[AnyTask] = []
 
     def __init__(
         self,
@@ -53,6 +54,7 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
         retry: int = 2,
         retry_interval: Union[float, int] = 1,
         upstreams: Iterable[AnyTask] = [],
+        fallbacks: Iterable[AnyTask] = [],
         checkers: Iterable[AnyTask] = [],
         checking_interval: Union[float, int] = 0,
         run: Optional[Callable[..., Any]] = None,
@@ -87,6 +89,7 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
             retry=retry,
             retry_interval=retry_interval,
             upstreams=upstreams,
+            fallbacks=fallbacks,
             checkers=checkers,
             checking_interval=checking_interval,
             run=run,
@@ -257,7 +260,7 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
         except Exception as e:
             self.log_error(f"{e}")
             if raise_error:
-                raise
+                raise e
         finally:
             if show_done_info:
                 self._show_env_prefix()
@@ -303,7 +306,7 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
         self.log_debug("Waiting execution to be started")
         while not self.__is_execution_started:
             # Don't start checking before the execution itself has been started
-            await asyncio.sleep(0.1)
+            await asyncio.sleep(0.05)
         check_coroutines: Iterable[asyncio.Task] = []
         for checker_task in self._get_checkers():
             checker_task._set_execution_id(self.get_execution_id())
@@ -334,15 +337,7 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
         await self.on_triggered()
         self.__is_execution_triggered = True
         await self.on_waiting()
-        # get upstream checker
-        upstream_check_processes: Iterable[asyncio.Task] = []
-        self._lock_upstreams()
-        for upstream_task in self._get_upstreams():
-            upstream_check_processes.append(
-                asyncio.create_task(upstream_task._loop_check())
-            )
-        # wait all upstream checkers to complete
-        await asyncio.gather(*upstream_check_processes)
+        await self.__check_upstreams()
         # mark execution as started, so that checkers can start checking
         self.__is_execution_started = True
         local_kwargs = dict(kwargs)
@@ -353,27 +348,70 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
             return None
         # start running task
         result: Any = None
+        is_failed: bool = False
         while self._should_attempt():
             try:
                 self.log_debug(f"Started with args: {args} and kwargs: {local_kwargs}")
                 await self.on_started()
+                self.__running_tasks.append(self)
                 result = await run_async(self.run, *args, **local_kwargs)
+                self.__running_tasks.remove(self)
                 break
             except Exception as e:
-                is_last_attempt = self._is_last_attempt()
-                await self.on_failed(is_last_attempt, e)
-                if is_last_attempt:
-                    raise e
                 attempt = self._get_attempt()
                 self.log_error(f"Encounter error on attempt {attempt}")
+                if self._is_last_attempt():
+                    is_failed = True
+                    raise e
+                self.__running_tasks.remove(self)
+                await self.on_failed(is_last_attempt=False, exception=e)
                 self._increase_attempt()
                 await asyncio.sleep(self._retry_interval)
                 await self.on_retry()
+            finally:
+                if is_failed:
+                    running_tasks = self.__running_tasks
+                    self.__running_tasks = []
+                    await self.__trigger_failure(running_tasks)
+                    await self.__trigger_fallbacks(running_tasks, kwargs)
         self.set_xcom(self.get_name(), f"{result}")
         self.log_debug(f"XCom: {self.__xcom}")
         await self._mark_done()
         return result
 
+    async def __check_upstreams(self):
+        coroutines: Iterable[asyncio.Task] = []
+        self._lock_upstreams()
+        for upstream_task in self._get_upstreams():
+            coroutines.append(asyncio.create_task(upstream_task._loop_check()))
+        # wait all upstream checkers to complete
+        await asyncio.gather(*coroutines)
+
+    async def __trigger_failure(self, tasks: List[AnyTask]):
+        coroutines = [
+            task.on_failed(is_last_attempt=True, exception=Exception("canceled"))
+            for task in tasks
+        ]
+        await asyncio.gather(*coroutines)
+
+    async def __trigger_fallbacks(
+        self, tasks: List[AnyTask], kwargs: Mapping[str, Any]
+    ):
+        coroutines: Iterable[asyncio.Task] = []
+        for fallback in self.__get_all_fallbacks(tasks):
+            fallback._set_execution_id(self.get_execution_id())
+            coroutines.append(asyncio.create_task(fallback._run_all(**kwargs)))
+        await asyncio.gather(*coroutines)
+
+    def __get_all_fallbacks(self, tasks: List[AnyTask]) -> List[AnyTask]:
+        all_fallbacks: List[AnyTask] = []
+        for task in tasks:
+            task._lock_fallbacks()
+            for fallback in task._get_fallbacks():
+                if fallback not in all_fallbacks:
+                    all_fallbacks.append(fallback)
+        return all_fallbacks
+
     async def _check_should_execute(self, *args: Any, **kwargs: Any) -> bool:
         if callable(self._should_execute):
             return await run_async(self._should_execute, *args, **kwargs)

zrb/task/base_task/component/base_task_model.py

@@ -56,6 +56,7 @@ class BaseTaskModel(CommonTaskModel, PidModel, TimeTracker):
         retry: int = 2,
         retry_interval: Union[int, float] = 1,
         upstreams: Iterable[AnyTask] = [],
+        fallbacks: Iterable[AnyTask] = [],
         checkers: Iterable[AnyTask] = [],
         checking_interval: Union[int, float] = 0,
         run: Optional[Callable[..., Any]] = None,
@@ -85,6 +86,7 @@ class BaseTaskModel(CommonTaskModel, PidModel, TimeTracker):
             retry=retry,
             retry_interval=retry_interval,
             upstreams=upstreams,
+            fallbacks=fallbacks,
             checkers=checkers,
             checking_interval=checking_interval,
             run=run,

zrb/task/base_task/component/common_task_model.py

@@ -47,6 +47,7 @@ class CommonTaskModel:
         retry: int = 2,
         retry_interval: Union[float, int] = 1,
         upstreams: Iterable[AnyTask] = [],
+        fallbacks: Iterable[AnyTask] = [],
         checkers: Iterable[AnyTask] = [],
         checking_interval: Union[float, int] = 0,
         run: Optional[Callable[..., Any]] = None,
@@ -73,6 +74,7 @@ class CommonTaskModel:
         self._retry = retry
         self._retry_interval = retry_interval
         self._upstreams = upstreams
+        self._fallbacks = fallbacks
         self._checkers = [checker.copy() for checker in checkers]
         self._checking_interval = checking_interval
         self._run_function: Optional[Callable[..., Any]] = run
@@ -90,16 +92,21 @@ class CommonTaskModel:
         self.__allow_add_env_files = True
         self.__allow_add_inputs = True
         self.__allow_add_upstreams: bool = True
+        self.__allow_add_fallbacks: bool = True
         self.__allow_add_checkers: 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_upstreams: bool = False
+        self.__has_already_inject_fallbacks: bool = False
         self.__all_inputs: Optional[List[AnyInput]] = None
 
     def _lock_upstreams(self):
         self.__allow_add_upstreams = False
 
+    def _lock_fallbacks(self):
+        self.__allow_add_fallbacks = False
+
     def _set_execution_id(self, execution_id: str):
         if self.__execution_id == "":
             self.__execution_id = execution_id
@@ -276,6 +283,25 @@ class CommonTaskModel:
             self.__has_already_inject_upstreams = True
         return list(self._upstreams)
 
+    def insert_fallback(self, *fallbacks: AnyTask):
+        if not self.__allow_add_fallbacks:
+            raise Exception(f"Cannot insert fallbacks to `{self.get_name()}`")
+        self._fallbacks = list(fallbacks) + list(self._fallbacks)
+
+    def add_fallback(self, *fallbacks: AnyTask):
+        if not self.__allow_add_fallbacks:
+            raise Exception(f"Cannot add fallbacks to `{self.get_name()}`")
+        self._fallbacks = list(self._fallbacks) + list(fallbacks)
+
+    def inject_fallbacks(self):
+        pass
+
+    def _get_fallbacks(self) -> List[AnyTask]:
+        if not self.__has_already_inject_fallbacks:
+            self.inject_fallbacks()
+            self.__has_already_inject_fallbacks = True
+        return list(self._fallbacks)
+
     def get_icon(self) -> str:
         return self._icon
 

zrb/task/checker.py

@@ -32,6 +32,7 @@ class Checker(BaseTask):
         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,
@@ -55,6 +56,7 @@ class Checker(BaseTask):
             color=color,
             description=description,
             upstreams=upstreams,
+            fallbacks=fallbacks,
             on_triggered=on_triggered,
             on_waiting=on_waiting,
             on_skipped=on_skipped,

zrb/task/cmd_task.py

@@ -113,6 +113,7 @@ class CmdTask(BaseTask):
         cmd_path: CmdVal = "",
         cwd: Optional[Union[str, pathlib.Path]] = None,
         upstreams: Iterable[AnyTask] = [],
+        fallbacks: Iterable[AnyTask] = [],
         on_triggered: Optional[OnTriggered] = None,
         on_waiting: Optional[OnWaiting] = None,
         on_skipped: Optional[OnSkipped] = None,
@@ -141,6 +142,7 @@ class CmdTask(BaseTask):
             color=color,
             description=description,
             upstreams=upstreams,
+            fallbacks=fallbacks,
             on_triggered=on_triggered,
             on_waiting=on_waiting,
             on_skipped=on_skipped,