zrb 0.23.4__py3-none-any.whl → 0.24.1__py3-none-any.whl

zrb/task/base_task/component/common_task_model.py

@@ -1,19 +1,12 @@
 import os
+from collections.abc import Callable, Iterable, Mapping
+from typing import Any, Optional, Union
 
 from zrb.helper.accessories.color import get_random_color
 from zrb.helper.accessories.icon import get_random_icon
 from zrb.helper.string.conversion import to_cli_name
 from zrb.helper.typecheck import typechecked
-from zrb.helper.typing import (
-    Any,
-    Callable,
-    Iterable,
-    JinjaTemplate,
-    List,
-    Mapping,
-    Optional,
-    Union,
-)
+from zrb.helper.typing import JinjaTemplate
 from zrb.helper.util import coalesce_str
 from zrb.task.any_task import AnyTask
 from zrb.task.any_task_event_handler import (
@@ -39,7 +32,7 @@ class CommonTaskModel:
         name: str,
         group: Optional[Group] = None,
         description: str = "",
-        inputs: List[AnyInput] = [],
+        inputs: list[AnyInput] = [],
         envs: Iterable[Env] = [],
         env_files: Iterable[EnvFile] = [],
         icon: Optional[str] = None,
@@ -65,7 +58,7 @@ class CommonTaskModel:
         self._group = group
         if group is not None:
             group._add_task(self)
-        checkers_cp: List[AnyTask] = [checker.copy() for checker in checkers]
+        checkers_cp: list[AnyTask] = [checker.copy() for checker in checkers]
         for checker in checkers_cp:
             checker.add_env(*envs)
             checker.add_env_file(*env_files)
@@ -104,7 +97,7 @@ class CommonTaskModel:
         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
+        self.__all_inputs: Optional[list[AnyInput]] = None
 
     def _lock_checkers(self):
         self.__allow_add_checkers = False
@@ -185,7 +178,7 @@ class CommonTaskModel:
     def inject_inputs(self):
         pass
 
-    def _get_inputs(self) -> List[AnyInput]:
+    def _get_inputs(self) -> list[AnyInput]:
         if not self.__has_already_inject_inputs:
             self.inject_inputs()
             self.__has_already_inject_inputs = True
@@ -197,7 +190,7 @@ class CommonTaskModel:
         """
         if self.__all_inputs is not None:
             return self.__all_inputs
-        self.__all_inputs: List[AnyInput] = []
+        self.__all_inputs: list[AnyInput] = []
         existing_input_names: Mapping[str, bool] = {}
         # Add task inputs
         inputs = self._get_inputs()
@@ -244,7 +237,7 @@ class CommonTaskModel:
     def inject_envs(self):
         pass
 
-    def _get_envs(self) -> List[Env]:
+    def _get_envs(self) -> list[Env]:
         if not self.__has_already_inject_envs:
             self.inject_envs()
             self.__has_already_inject_envs = True
@@ -297,7 +290,7 @@ class CommonTaskModel:
     def inject_upstreams(self):
         pass
 
-    def _get_upstreams(self) -> List[AnyTask]:
+    def _get_upstreams(self) -> list[AnyTask]:
         if not self.__has_already_inject_upstreams:
             self.inject_upstreams()
             self.__has_already_inject_upstreams = True
@@ -316,7 +309,7 @@ class CommonTaskModel:
     def inject_fallbacks(self):
         pass
 
-    def _get_fallbacks(self) -> List[AnyTask]:
+    def _get_fallbacks(self) -> list[AnyTask]:
         if not self.__has_already_inject_fallbacks:
             self.inject_fallbacks()
             self.__has_already_inject_fallbacks = True
@@ -328,7 +321,7 @@ class CommonTaskModel:
     def get_color(self) -> str:
         return self._color
 
-    def _get_env_files(self) -> List[EnvFile]:
+    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
@@ -346,11 +339,11 @@ class CommonTaskModel:
         additional_checkers = self.__complete_new_checkers(checkers)
         self._checkers = self._checkers + additional_checkers
 
-    def __complete_new_checkers(self, new_checkers: List[AnyTask]) -> List[AnyTask]:
+    def __complete_new_checkers(self, new_checkers: Iterable[AnyTask]) -> list[AnyTask]:
         """
         For internal use: copy and completing new checkers
         """
-        checkers: List[AnyTask] = [checker.copy() for checker in new_checkers]
+        checkers: list[AnyTask] = [checker.copy() for checker in new_checkers]
         for checker in checkers:
             checker.add_input(*self._get_inputs())
             checker.add_env(*self._get_envs())
@@ -360,7 +353,7 @@ class CommonTaskModel:
     def inject_checkers(self):
         pass
 
-    def _get_checkers(self) -> List[AnyTask]:
+    def _get_checkers(self) -> list[AnyTask]:
         if not self.__allow_add_checkers:
             self.inject_checkers()
             self.__allow_add_checkers = True

zrb/task/base_task/component/renderer.py

@@ -1,4 +1,6 @@
 import os
+from collections.abc import Mapping
+from typing import Any, Optional, Union
 
 import jinja2
 
@@ -6,7 +8,7 @@ from zrb.helper.render_data import DEFAULT_RENDER_DATA
 from zrb.helper.string.conversion import to_boolean
 from zrb.helper.string.jinja import is_probably_jinja
 from zrb.helper.typecheck import typechecked
-from zrb.helper.typing import Any, JinjaTemplate, Mapping, Optional, Union
+from zrb.helper.typing import JinjaTemplate
 from zrb.task.any_task import AnyTask
 
 

zrb/task/base_task/component/trackers.py

@@ -1,8 +1,8 @@
 import asyncio
 import time
+from typing import Optional, Union
 
 from zrb.helper.typecheck import typechecked
-from zrb.helper.typing import Optional, Union
 
 LOG_NAME_LENGTH = 20
 

zrb/task/checker.py

@@ -1,9 +1,10 @@
 import asyncio
+from collections.abc import Callable, Iterable
+from typing import Any, Optional, Union
 
 from zrb.helper.accessories.color import colored
 from zrb.helper.log import logger
 from zrb.helper.typecheck import typechecked
-from zrb.helper.typing import Any, Callable, Iterable, Optional, Union
 from zrb.task.any_task import AnyTask
 from zrb.task.any_task_event_handler import (
     OnFailed,

zrb/task/cmd_task.py

@@ -7,21 +7,14 @@ import signal
 import subprocess
 import sys
 import time
+from collections.abc import Callable, Iterable
+from typing import Any, Optional, TypeVar, Union
 
-from zrb.config.config import default_shell, logging_level
+from zrb.config.config import DEFAULT_SHELL, LOGGING_LEVEL
 from zrb.helper.accessories.color import colored
 from zrb.helper.log import logger
 from zrb.helper.typecheck import typechecked
-from zrb.helper.typing import (
-    Any,
-    Callable,
-    Iterable,
-    JinjaTemplate,
-    List,
-    Optional,
-    TypeVar,
-    Union,
-)
+from zrb.helper.typing import JinjaTemplate
 from zrb.task.any_task import AnyTask
 from zrb.task.any_task_event_handler import (
     OnFailed,
@@ -57,7 +50,7 @@ def _reset_stty():
 
 
 def _log_error(message: Any):
-    if logging_level > logging.ERROR:
+    if LOGGING_LEVEL > logging.ERROR:
         return
     colored_message = colored(f"{message}", color="red", attrs=["bold"])
     logger.error(colored_message, exc_info=True)
@@ -111,7 +104,7 @@ class CmdTask(BaseTask):
         >>> runner.register(hello)
     """
 
-    _pids: List[int] = []
+    _pids: list[int] = []
     _global_state = CmdGlobalState()
 
     def __init__(
@@ -187,8 +180,8 @@ class CmdTask(BaseTask):
         self._max_error_size = max_error_line
         self._output_buffer: Iterable[str] = []
         self._error_buffer: Iterable[str] = []
-        if executable is None and default_shell != "":
-            executable = default_shell
+        if executable is None and DEFAULT_SHELL != "":
+            executable = DEFAULT_SHELL
         self._executable = executable
         self._process: Optional[asyncio.subprocess.Process]
         self._preexec_fn = preexec_fn

zrb/task/decorator.py

@@ -1,8 +1,10 @@
+from collections.abc import Callable, Iterable
+from typing import Any, Optional, Union
+
 from zrb.action.runner import Runner
 from zrb.helper.accessories.color import colored
 from zrb.helper.log import logger
 from zrb.helper.typecheck import typechecked
-from zrb.helper.typing import Any, Callable, Iterable, Optional, Union
 from zrb.task.any_task import AnyTask
 from zrb.task.any_task_event_handler import (
     OnFailed,

zrb/task/docker_compose_start_task.py

@@ -0,0 +1,146 @@
+import os
+import pathlib
+from collections.abc import Callable, Iterable, Mapping
+from typing import Any, Optional, Union
+
+from zrb.helper.accessories.color import colored
+from zrb.helper.log import logger
+from zrb.helper.typecheck import typechecked
+from zrb.helper.typing import JinjaTemplate
+from zrb.task.any_task import AnyTask
+from zrb.task.any_task_event_handler import (
+    OnFailed,
+    OnReady,
+    OnRetry,
+    OnSkipped,
+    OnStarted,
+    OnTriggered,
+    OnWaiting,
+)
+from zrb.task.cmd_task import CmdVal
+from zrb.task.docker_compose_task import DockerComposeTask, ServiceConfig
+from zrb.task_env.env import Env
+from zrb.task_env.env_file import EnvFile
+from zrb.task_group.group import Group
+from zrb.task_input.any_input import AnyInput
+
+logger.debug(colored("Loading zrb.task.docker_compose_task", attrs=["dark"]))
+
+
+@typechecked
+class DockerComposeStartTask(DockerComposeTask):
+    def __init__(
+        self,
+        name: str,
+        group: Optional[Group] = None,
+        inputs: Iterable[AnyInput] = [],
+        envs: Iterable[Env] = [],
+        env_files: Iterable[EnvFile] = [],
+        icon: Optional[str] = None,
+        color: Optional[str] = None,
+        description: str = "",
+        executable: Optional[str] = None,
+        compose_service_configs: Mapping[str, ServiceConfig] = {},
+        compose_file: Optional[str] = None,
+        compose_options: Mapping[JinjaTemplate, JinjaTemplate] = {},
+        compose_flags: Iterable[JinjaTemplate] = [],
+        compose_args: Iterable[JinjaTemplate] = [],
+        compose_env_prefix: str = "",
+        setup_cmd: CmdVal = "",
+        setup_cmd_path: CmdVal = "",
+        cwd: Optional[Union[JinjaTemplate, pathlib.Path]] = None,
+        should_render_cwd: bool = True,
+        upstreams: Iterable[AnyTask] = [],
+        fallbacks: Iterable[AnyTask] = [],
+        on_triggered: Optional[OnTriggered] = None,
+        on_waiting: Optional[OnWaiting] = None,
+        on_skipped: Optional[OnSkipped] = None,
+        on_started: Optional[OnStarted] = None,
+        on_ready: Optional[OnReady] = None,
+        on_retry: Optional[OnRetry] = None,
+        on_failed: Optional[OnFailed] = None,
+        checkers: Iterable[AnyTask] = [],
+        checking_interval: Union[float, int] = 0.05,
+        retry: int = 2,
+        retry_interval: Union[float, int] = 1,
+        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,
+        return_upstream_result: bool = False,
+        should_print_cmd_result: bool = True,
+        should_show_cmd: bool = True,
+        should_show_working_directory: bool = True,
+    ):
+        DockerComposeTask.__init__(
+            self,
+            name=name,
+            group=group,
+            inputs=inputs,
+            envs=envs,
+            env_files=env_files,
+            icon=icon,
+            color=color,
+            description=description,
+            executable=executable,
+            compose_service_configs=compose_service_configs,
+            compose_file=compose_file,
+            compose_options=compose_options,
+            compose_flags=compose_flags,
+            compose_args=compose_args,
+            compose_env_prefix=compose_env_prefix,
+            setup_cmd=setup_cmd,
+            setup_cmd_path=setup_cmd_path,
+            cwd=cwd,
+            should_render_cwd=should_render_cwd,
+            upstreams=upstreams,
+            fallbacks=fallbacks,
+            on_triggered=on_triggered,
+            on_waiting=on_waiting,
+            on_skipped=on_skipped,
+            on_started=on_started,
+            on_ready=on_ready,
+            on_retry=on_retry,
+            on_failed=on_failed,
+            checkers=checkers,
+            checking_interval=checking_interval,
+            retry=retry,
+            retry_interval=retry_interval,
+            max_output_line=max_output_line,
+            max_error_line=max_error_line,
+            preexec_fn=preexec_fn,
+            should_execute=should_execute,
+            return_upstream_result=return_upstream_result,
+            should_print_cmd_result=should_print_cmd_result,
+            should_show_cmd=should_show_cmd,
+            should_show_working_directory=should_show_working_directory,
+        )
+
+    def get_cmd_script(self, *args: Any, **kwargs: Any) -> str:
+        # setup
+        setup_cmd = self._create_cmd_script(
+            self._setup_cmd_path, self._setup_cmd, *args, **kwargs
+        )
+        cmd_list = [setup_cmd] if setup_cmd.strip() != "" else []
+        # compose command
+        cmd_list = cmd_list + [
+            # compose start
+            self._get_docker_compose_cmd_script(
+                compose_cmd="up",
+                compose_options=self._compose_options,
+                compose_flags=list(self._compose_flags) + ["-d"],
+                compose_args=self._compose_args,
+                *args,
+            ),
+            # compose log
+            self._get_docker_compose_cmd_script(
+                compose_cmd="logs",
+                compose_options={},
+                compose_flags=["-f"],
+                compose_args=[],
+                *args,
+            ),
+        ]
+        cmd_str = "\n".join(cmd_list)
+        self.log_info(f"Command: {cmd_str}")
+        return cmd_str

zrb/task/docker_compose_task.py

@@ -1,7 +1,9 @@
 import os
 import pathlib
+from collections.abc import Callable, Iterable, Mapping
+from typing import Any, Optional, TypeVar, Union
 
-from zrb.config.config import container_backend
+from zrb.config.config import CONTAINER_BACKEND
 from zrb.helper.accessories.color import colored
 from zrb.helper.accessories.name import get_random_name
 from zrb.helper.docker_compose.fetch_external_env import fetch_compose_file_env_map
@@ -10,17 +12,7 @@ from zrb.helper.log import logger
 from zrb.helper.string.conversion import to_cli_name
 from zrb.helper.string.modification import double_quote
 from zrb.helper.typecheck import typechecked
-from zrb.helper.typing import (
-    Any,
-    Callable,
-    Iterable,
-    JinjaTemplate,
-    List,
-    Mapping,
-    Optional,
-    TypeVar,
-    Union,
-)
+from zrb.helper.typing import JinjaTemplate
 from zrb.helper.util import to_snake_case
 from zrb.task.any_task import AnyTask
 from zrb.task.any_task_event_handler import (
@@ -66,19 +58,19 @@ def _get_ensure_zrb_network_task(backend: str):
 
 
 TDockerComposeTask = TypeVar("TDockerComposeTask", bound="DockerComposeTask")
-ensure_zrb_network_task = _get_ensure_zrb_network_task(container_backend)
+ensure_zrb_network_task = _get_ensure_zrb_network_task(CONTAINER_BACKEND)
 
 
 @typechecked
 class ServiceConfig:
-    def __init__(self, envs: List[Env] = [], env_files: List[EnvFile] = []):
+    def __init__(self, envs: list[Env] = [], env_files: list[EnvFile] = []):
         self._envs = envs
         self._env_files = env_files
 
-    def get_envs(self) -> List[Env]:
+    def get_envs(self) -> list[Env]:
         return self._envs
 
-    def get_env_files(self) -> List[EnvFile]:
+    def get_env_files(self) -> list[EnvFile]:
         return self._env_files
 
 
@@ -224,7 +216,7 @@ class DockerComposeTask(CmdTask):
     def __generate_compose_runtime_file(self):
         compose_data = read_compose_file(self._compose_template_file)
         for service, service_config in self._compose_service_configs.items():
-            envs: List[Env] = []
+            envs: list[Env] = []
             env_files = service_config.get_env_files()
             for env_file in env_files:
                 envs += env_file.get_envs()
@@ -233,7 +225,7 @@ class DockerComposeTask(CmdTask):
         write_compose_file(self._compose_runtime_file, compose_data)
 
     def __apply_service_env(
-        self, compose_data: Any, service_name: str, envs: List[Env]
+        self, compose_data: Any, service_name: str, envs: list[Env]
     ) -> Any:
         # service not found
         service_map = compose_data["services"]
@@ -269,7 +261,7 @@ class DockerComposeTask(CmdTask):
         return compose_data
 
     def __get_service_new_env_map(
-        self, service_name: str, service_env_map: Mapping[str, str], new_envs: List[Env]
+        self, service_name: str, service_env_map: Mapping[str, str], new_envs: list[Env]
     ) -> Mapping[str, str]:
         new_service_envs: Mapping[str, str] = {}
         for env in new_envs:
@@ -280,9 +272,9 @@ class DockerComposeTask(CmdTask):
         return new_service_envs
 
     def __get_service_new_env_list(
-        self, service_name: str, service_env_list: List[str], new_envs: List[Env]
-    ) -> List[str]:
-        new_service_envs: List[str] = []
+        self, service_name: str, service_env_list: list[str], new_envs: list[Env]
+    ) -> list[str]:
+        new_service_envs: list[str] = []
         for env in new_envs:
             should_be_added = 0 == len(
                 [
@@ -341,10 +333,34 @@ class DockerComposeTask(CmdTask):
         raise Exception(f"Invalid compose file: {compose_file}")
 
     def get_cmd_script(self, *args: Any, **kwargs: Any) -> str:
-        setup_cmd_str = self._create_cmd_script(
+        # setup
+        setup_cmd = self._create_cmd_script(
             self._setup_cmd_path, self._setup_cmd, *args, **kwargs
         )
-        command_options = dict(self._compose_options)
+        cmd_list = [setup_cmd] if setup_cmd.strip() != "" else []
+        # compose command
+        cmd_list.append(
+            self._get_docker_compose_cmd_script(
+                compose_cmd=self._compose_cmd,
+                compose_options=self._compose_options,
+                compose_flags=self._compose_flags,
+                compose_args=self._compose_args,
+                *args,
+            )
+        )
+        cmd_str = "\n".join(cmd_list)
+        self.log_info(f"Command: {cmd_str}")
+        return cmd_str
+
+    def _get_docker_compose_cmd_script(
+        self,
+        compose_cmd: str,
+        compose_options: Mapping[JinjaTemplate, JinjaTemplate],
+        compose_flags: Iterable[JinjaTemplate],
+        compose_args: Iterable[JinjaTemplate],
+        *args: Any,
+    ) -> str:
+        command_options = dict(compose_options)
         command_options["--file"] = self._compose_runtime_file
         options = " ".join(
             [
@@ -356,22 +372,15 @@ class DockerComposeTask(CmdTask):
         flags = " ".join(
             [
                 self.render_str(flag)
-                for flag in self._compose_flags
+                for flag in compose_flags
                 if self.render_str(flag) != ""
             ]
         )
         args = " ".join(
             [
                 double_quote(self.render_str(arg))
-                for arg in self._compose_args
+                for arg in compose_args
                 if self.render_str(arg) != ""
             ]
         )
-        cmd_str = "\n".join(
-            [
-                setup_cmd_str,
-                f"{container_backend} compose {options} {self._compose_cmd} {flags} {args}",  # noqa
-            ]
-        )
-        self.log_info(f"Command: {cmd_str}")
-        return cmd_str
+        return f"{CONTAINER_BACKEND} compose {options} {compose_cmd} {flags} {args}"

zrb/task/flow_task.py

@@ -1,7 +1,9 @@
+from collections.abc import Callable, Iterable
+from typing import Optional, TypeVar, Union
+
 from zrb.helper.accessories.color import colored
 from zrb.helper.log import logger
 from zrb.helper.typecheck import typechecked
-from zrb.helper.typing import Callable, Iterable, List, Optional, TypeVar, Union
 from zrb.task.any_task import AnyTask
 from zrb.task.any_task_event_handler import (
     OnFailed,
@@ -48,7 +50,7 @@ class FlowTask(BaseTask):
         checking_interval: Union[float, int] = 0.05,
         retry: int = 2,
         retry_interval: Union[float, int] = 1,
-        steps: List[Union[AnyTask, List[AnyTask]]] = [],
+        steps: list[Union[AnyTask, list[AnyTask]]] = [],
         should_execute: Union[bool, str, Callable[..., bool]] = True,
         return_upstream_result: bool = False,
     ):
@@ -91,12 +93,12 @@ class FlowTask(BaseTask):
 
     def _create_flow_upstreams(
         self,
-        steps: List[Union[AnyTask, List[AnyTask]]],
-        upstreams: List[AnyTask],
-        inputs: List[AnyInput],
-        envs: List[Env],
-        env_files: List[EnvFile],
-    ) -> List[AnyTask]:
+        steps: list[Union[AnyTask, list[AnyTask]]],
+        upstreams: list[AnyTask],
+        inputs: list[AnyInput],
+        envs: list[Env],
+        env_files: list[EnvFile],
+    ) -> list[AnyTask]:
         flow_upstreams = upstreams
         for step in steps:
             tasks = [task.copy() for task in self._step_to_tasks(step)]
@@ -110,20 +112,20 @@ class FlowTask(BaseTask):
             flow_upstreams = new_upstreams
         return flow_upstreams
 
-    def _step_to_tasks(self, step: Union[AnyTask, List[AnyTask]]) -> List[AnyTask]:
+    def _step_to_tasks(self, step: Union[AnyTask, list[AnyTask]]) -> list[AnyTask]:
         if isinstance(step, AnyTask):
             return [step]
         return step
 
     def _create_embeded_tasks(
         self,
-        tasks: List[AnyTask],
-        upstreams: List[AnyTask],
-        inputs: List[AnyInput],
-        envs: List[Env],
-        env_files: List[EnvFile],
-    ) -> List[AnyTask]:
-        embeded_tasks: List[AnyTask] = []
+        tasks: list[AnyTask],
+        upstreams: list[AnyTask],
+        inputs: list[AnyInput],
+        envs: list[Env],
+        env_files: list[EnvFile],
+    ) -> list[AnyTask]:
+        embeded_tasks: list[AnyTask] = []
         for embeded_task in tasks:
             embeded_task_upstreams = self._get_all_upstreams(tasks=[embeded_task])
             for embeded_task_upstream in embeded_task_upstreams:
@@ -134,7 +136,7 @@ class FlowTask(BaseTask):
             embeded_tasks.append(embeded_task)
         return embeded_tasks
 
-    def _get_all_upstreams(self, tasks: List[AnyTask]):
+    def _get_all_upstreams(self, tasks: list[AnyTask]):
         all_upstreams = []
         for task in tasks:
             upstreams = task._get_upstreams()

zrb/task/http_checker.py

@@ -1,17 +1,11 @@
+from collections.abc import Callable, Iterable
 from http.client import HTTPConnection, HTTPSConnection
+from typing import Any, Optional, TypeVar, Union
 
 from zrb.helper.accessories.color import colored
 from zrb.helper.log import logger
 from zrb.helper.typecheck import typechecked
-from zrb.helper.typing import (
-    Any,
-    Callable,
-    Iterable,
-    JinjaTemplate,
-    Optional,
-    TypeVar,
-    Union,
-)
+from zrb.helper.typing import JinjaTemplate
 from zrb.task.any_task import AnyTask
 from zrb.task.any_task_event_handler import (
     OnFailed,

zrb/task/looper.py

@@ -1,14 +1,16 @@
+from collections.abc import Callable
+from typing import Optional
+
 from zrb.helper.accessories.color import colored
 from zrb.helper.callable import run_async
 from zrb.helper.log import logger
-from zrb.helper.typing import Callable, List, Mapping, Optional
 
 logger.debug(colored("Loading zrb.task.looper", attrs=["dark"]))
 
 
 class Looper:
     def __init__(self):
-        self._queue: Mapping[str, List[Optional[bool]]] = {}
+        self._queue: Mapping[str, list[Optional[bool]]] = {}
         self._should_stop = False
 
     async def pop(self, identifier: str) -> Optional[bool]:

zrb/task/notifier.py

@@ -1,12 +1,14 @@
 import os
 import subprocess
+from collections.abc import Callable, Iterable
+from typing import Any, Optional, Union
 
 from zrb.helper.accessories.color import colored
 from zrb.helper.accessories.icon import get_random_icon
 from zrb.helper.log import logger
 from zrb.helper.string.modification import double_quote
 from zrb.helper.typecheck import typechecked
-from zrb.helper.typing import Any, Callable, Iterable, JinjaTemplate, Optional, Union
+from zrb.helper.typing import JinjaTemplate
 from zrb.task.any_task import AnyTask
 from zrb.task.any_task_event_handler import (
     OnFailed,