zrb 0.26.2__py3-none-any.whl → 0.28.0__py3-none-any.whl

zrb/__init__.py

@@ -10,7 +10,6 @@ from zrb.task.any_task_event_handler import (
     OnTriggered,
     OnWaiting,
 )
-from zrb.task.base_remote_cmd_task import BaseRemoteCmdTask, RemoteConfig
 from zrb.task.checker import Checker
 from zrb.task.cmd_task import CmdTask
 from zrb.task.decorator import python_task
@@ -69,8 +68,6 @@ assert CmdTask
 assert DockerComposeTask
 assert DockerComposeStartTask
 assert ServiceConfig
-assert BaseRemoteCmdTask
-assert RemoteConfig
 assert RemoteCmdTask
 assert RsyncTask
 assert Notifier

zrb/action/runner.py

@@ -1,4 +1,3 @@
-import sys
 from collections.abc import Callable, Mapping
 from typing import Any, Union
 
@@ -122,7 +121,6 @@ class Runner:
                 function(*args, **kwargs)
             except Exception:
                 stop_asyncio_sync()
-                sys.exit(1)
             finally:
                 task.clear_xcom()
 

zrb/builtin/devtool/install/zsh/install.sh

@@ -48,7 +48,7 @@ fi
 if command_exists chsh
 then
     log_info "Changing default shell to zsh..."
-     try_sudo chsh -s zsh
+    chsh -s $(which zsh)
 else
     log_info "chsh command not found. Please change the default shell manually."
 fi

zrb/builtin/project/add/fastapp/app/template/_automate/snake_zrb_app_name/container/microservices/start.py

@@ -21,7 +21,6 @@ from .._input import enable_monitoring_input
 from .._service_config import snake_zrb_app_name_service_configs
 from ..remove import remove_snake_zrb_app_name_container
 from ._group import snake_zrb_app_name_microservices_container_group
-from ._helper import activate_microservices_compose_profile
 
 start_snake_zrb_app_name_microservices_container = DockerComposeStartTask(
     icon="🐳",
@@ -38,7 +37,13 @@ start_snake_zrb_app_name_microservices_container = DockerComposeStartTask(
     should_execute="{{ input.local_snake_zrb_app_name}}",
     upstreams=[build_snake_zrb_app_name_image, remove_snake_zrb_app_name_container],
     cwd=RESOURCE_DIR,
-    setup_cmd=activate_microservices_compose_profile,
+    compose_profiles=[
+        '{{"postgres" if env.APP_DB_CONNECTION.startswith("postgresql") else ""}}',
+        '{{"kafka" if env.APP_BROKER_TYPE == "kafka" else ""}}',
+        '{{"rabbitmq" if env.APP_BROKER_TYPE == "rabbitmq" else ""}}',
+        '{{"monitoring" if input.enable_snake_zrb_app_name_monitoring else ""}}',
+        "microservices",
+    ],
     compose_env_prefix="CONTAINER_ZRB_ENV_PREFIX",
     compose_service_configs=snake_zrb_app_name_service_configs,
     env_files=[compose_env_file],

zrb/builtin/project/add/fastapp/app/template/_automate/snake_zrb_app_name/container/monolith/start.py

@@ -21,7 +21,6 @@ from .._input import enable_monitoring_input
 from .._service_config import snake_zrb_app_name_service_configs
 from ..remove import remove_snake_zrb_app_name_container
 from ._group import snake_zrb_app_name_monolith_container_group
-from ._helper import activate_monolith_compose_profile
 
 start_snake_zrb_app_name_monolith_container = DockerComposeStartTask(
     icon="🐳",
@@ -38,7 +37,13 @@ start_snake_zrb_app_name_monolith_container = DockerComposeStartTask(
     should_execute="{{ input.local_snake_zrb_app_name}}",
     upstreams=[build_snake_zrb_app_name_image, remove_snake_zrb_app_name_container],
     cwd=RESOURCE_DIR,
-    setup_cmd=activate_monolith_compose_profile,
+    compose_profiles=[
+        '{{"postgres" if env.APP_DB_CONNECTION.startswith("postgresql") else ""}}',
+        '{{"kafka" if env.APP_BROKER_TYPE == "kafka" else ""}}',
+        '{{"rabbitmq" if env.APP_BROKER_TYPE == "rabbitmq" else ""}}',
+        '{{"monitoring" if input.enable_snake_zrb_app_name_monitoring else ""}}',
+        "monolith",
+    ],
     compose_env_prefix="CONTAINER_ZRB_ENV_PREFIX",
     compose_service_configs=snake_zrb_app_name_service_configs,
     env_files=[compose_env_file],

zrb/builtin/project/add/fastapp/app/template/_automate/snake_zrb_app_name/container/remove.py

@@ -5,7 +5,6 @@ from .._constant import RESOURCE_DIR
 from ..image._env import image_env
 from ._env import compose_env_file
 from ._group import snake_zrb_app_name_container_group
-from ._helper import activate_all_compose_profile
 from ._service_config import snake_zrb_app_name_service_configs
 
 remove_snake_zrb_app_name_container = DockerComposeTask(
@@ -14,8 +13,15 @@ remove_snake_zrb_app_name_container = DockerComposeTask(
     description="Remove human readable zrb app name container",
     group=snake_zrb_app_name_container_group,
     cwd=RESOURCE_DIR,
-    setup_cmd=activate_all_compose_profile,
     compose_cmd="down",
+    compose_profiles=[
+        "postgres",
+        "kafka",
+        "rabbitmq",
+        "monitoring",
+        "monolith",
+        "microservices",
+    ],
     compose_env_prefix="CONTAINER_ZRB_ENV_PREFIX",
     compose_service_configs=snake_zrb_app_name_service_configs,
     env_files=[compose_env_file],

zrb/builtin/project/add/fastapp/app/template/_automate/snake_zrb_app_name/container/stop.py

@@ -5,7 +5,6 @@ from .._constant import RESOURCE_DIR
 from ..image._env import image_env
 from ._env import compose_env_file, host_port_env
 from ._group import snake_zrb_app_name_container_group
-from ._helper import activate_all_compose_profile
 from ._service_config import snake_zrb_app_name_service_configs
 
 stop_snake_zrb_app_name_container = DockerComposeTask(
@@ -14,8 +13,15 @@ stop_snake_zrb_app_name_container = DockerComposeTask(
     description="Stop human readable zrb app name container",
     group=snake_zrb_app_name_container_group,
     cwd=RESOURCE_DIR,
-    setup_cmd=activate_all_compose_profile,
     compose_cmd="stop",
+    compose_profiles=[
+        "postgres",
+        "kafka",
+        "rabbitmq",
+        "monitoring",
+        "monolith",
+        "microservices",
+    ],
     compose_env_prefix="CONTAINER_ZRB_ENV_PREFIX",
     compose_service_configs=snake_zrb_app_name_service_configs,
     env_files=[compose_env_file],

zrb/builtin/project/add/fastapp/app/template/_automate/snake_zrb_app_name/container/support/start.py

@@ -17,7 +17,6 @@ from .._input import enable_monitoring_input
 from .._service_config import snake_zrb_app_name_service_configs
 from ..remove import remove_snake_zrb_app_name_container
 from ._group import snake_zrb_app_name_support_container_group
-from ._helper import activate_support_compose_profile, should_start_support_container
 
 start_snake_zrb_app_name_support_container = DockerComposeStartTask(
     icon="🐳",
@@ -31,10 +30,23 @@ start_snake_zrb_app_name_support_container = DockerComposeStartTask(
         https_input,
         image_input,
     ],
-    should_execute=should_start_support_container,
     upstreams=[remove_snake_zrb_app_name_container],
     cwd=RESOURCE_DIR,
-    setup_cmd=activate_support_compose_profile,
+    should_execute=" ".join(
+        [
+            "{{",
+            'env.APP_DB_CONNECTION.startswith("postgresql")',
+            'or env.APP_BROKER_TYPE in ("kafka", "rabbitmq")',
+            "or input.enable_snake_zrb_app_name_monitoring",
+            "}}",
+        ]
+    ),
+    compose_profiles=[
+        '{{"postgres" if env.APP_DB_CONNECTION.startswith("postgresql") else ""}}',
+        '{{"kafka" if env.APP_BROKER_TYPE == "kafka" else ""}}',
+        '{{"rabbitmq" if env.APP_BROKER_TYPE == "rabbitmq" else ""}}',
+        '{{"monitoring" if input.enable_snake_zrb_app_name_monitoring else ""}}',
+    ],
     compose_env_prefix="CONTAINER_ZRB_ENV_PREFIX",
     compose_service_configs=snake_zrb_app_name_service_configs,
     env_files=[compose_env_file],

zrb/config/config.py

@@ -18,12 +18,6 @@ def _get_current_shell() -> str:
     return "bash"
 
 
-def _get_valid_container_backend(container_backend: str) -> str:
-    if container_backend.lower().strip() == "podman":
-        return "podman"
-    return "docker"
-
-
 def _get_default_tmp_dir() -> str:
     if os.path.isdir("/tmp"):
         return "/tmp"
@@ -52,7 +46,4 @@ SHOW_ADVERTISEMENT = untyped_to_boolean(os.getenv("ZRB_SHOW_ADVERTISEMENT", "1")
 SHOW_PROMPT = untyped_to_boolean(os.getenv("ZRB_SHOW_PROMPT", "1"))
 SHOW_TIME = untyped_to_boolean(os.getenv("ZRB_SHOW_TIME", "1"))
 VERSION = _get_version()
-CONTAINER_BACKEND = _get_valid_container_backend(
-    os.getenv("ZRB_CONTAINER_BACKEND", "docker")
-)
 ENABLE_TYPE_CHECKING = untyped_to_boolean(os.getenv("ZRB_ENABLE_TYPE_CHECKING", "1"))

zrb/helper/asyncio_task.py

@@ -1,4 +1,5 @@
 import asyncio
+import sys
 
 from zrb.helper.accessories.color import colored
 from zrb.helper.log import logger
@@ -6,11 +7,22 @@ from zrb.helper.log import logger
 logger.debug(colored("Loading zrb.helper.asyncio_task", attrs=["dark"]))
 
 
+def _surpress_event_loop_error(unraisable):
+    if not (
+        isinstance(unraisable.exc_value, RuntimeError)
+        and str(unraisable.exc_value) == "Event loop is closed"
+    ):
+        # Raise exception for anything except "event loop is closed"
+        sys.__unraisablehook__(unraisable)
+
+
+sys.unraisablehook = _surpress_event_loop_error
+
+
 async def stop_asyncio():
     tasks = [task for task in asyncio.all_tasks() if task is not asyncio.current_task()]
     for task in tasks:
         task.cancel()
-
     # Wait until all tasks are cancelled
     await asyncio.gather(*tasks, return_exceptions=True)
 
@@ -20,7 +32,5 @@ def stop_asyncio_sync():
         loop = asyncio.get_event_loop()
         if loop.is_running():
             loop.create_task(stop_asyncio())
-        else:
-            loop.run_until_complete(stop_asyncio())
-    except Exception:
-        pass
+    except asyncio.CancelledError:
+        logger.warning("Task is cancelled")

zrb/task/base_task/base_task.py

@@ -159,16 +159,15 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
     def copy(self) -> AnyTask:
         return copy.deepcopy(self)
 
-    def to_function(
+    def __get_async_function(
         self,
         env_prefix: str = "",
         raise_error: bool = True,
-        is_async: bool = False,
         show_done_info: bool = True,
         should_clear_xcom: bool = False,
         should_stop_looper: bool = False,
     ) -> Callable[..., Any]:
-        async def function(*args: Any, **kwargs: Any) -> Any:
+        async def async_function(*args: Any, **kwargs: Any) -> Any:
             self.log_info("Copy task")
             self_cp: AnyTask = self.copy()
             result = await self_cp._run_and_check_all(
@@ -184,9 +183,41 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
                 self_cp.clear_xcom()
             return result
 
+        return async_function
+
+    def __to_sync_function(
+        self, async_function: Callable[..., Any]
+    ) -> Callable[..., Any]:
+        def sync_function(*args: Any, **kwargs: Any) -> Any:
+            try:
+                return asyncio.run(async_function(*args, **kwargs))
+            except RuntimeError as e:
+                if "event loop is closed" not in str(e).lower():
+                    raise e
+            except asyncio.CancelledError:
+                self.print_out_dark("Task is cancelled")
+
+        return sync_function
+
+    def to_function(
+        self,
+        env_prefix: str = "",
+        raise_error: bool = True,
+        is_async: bool = False,
+        show_done_info: bool = True,
+        should_clear_xcom: bool = False,
+        should_stop_looper: bool = False,
+    ) -> Callable[..., Any]:
+        async_function = self.__get_async_function(
+            env_prefix=env_prefix,
+            raise_error=raise_error,
+            show_done_info=show_done_info,
+            should_clear_xcom=should_clear_xcom,
+            should_stop_looper=should_stop_looper,
+        )
         if is_async:
-            return function
-        return lambda *args, **kwargs: asyncio.run(function(*args, **kwargs))
+            return async_function
+        return self.__to_sync_function(async_function)
 
     async def run(self, *args: Any, **kwargs: Any) -> Any:
         if self._run_function is not None:
@@ -287,9 +318,6 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
             result = results[-1]
             self._print_result(result)
             return result
-        except RuntimeError as e:
-            if raise_error and ("event loop is closed" not in str(e).lower()):
-                raise e
         except Exception as e:
             self.log_error(f"{e}")
             if raise_error:
@@ -384,7 +412,9 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
         is_failed: bool = False
         while self._should_attempt():
             try:
-                self.log_debug(f"Started with args: {args} and kwargs: {local_kwargs}")
+                self.log_debug(
+                    f"Started with args: {args} and kwargs: {local_kwargs}"
+                )  # noqa
                 await self.on_started()
                 self.__running_tasks.append(self)
                 result = await run_async(self.run, *args, **local_kwargs)

zrb/task/cmd_task.py

@@ -291,8 +291,6 @@ class CmdTask(BaseTask):
         for pid in self._pids:
             self.__kill_by_pid(pid)
         stop_asyncio_sync()
-        _print_out_dark(f"Exiting with signal {signum}")
-        sys.exit(signum)
 
     def __on_exit(self):
         self._global_state.no_more_attempt = True
@@ -351,14 +349,15 @@ class CmdTask(BaseTask):
             )
         )
         # wait process
-        await process.wait()
-        # wait reader and logger
-        await stdout_process
-        await stderr_process
-        await stdout_queue.put(None)
-        await stderr_queue.put(None)
-        await stdout_log_process
-        await stderr_log_process
+        await asyncio.gather(
+            process.wait(),
+            stdout_process,
+            stderr_process,
+        )
+        # stop messages in queue
+        await asyncio.gather(stdout_queue.put(None), stderr_queue.put(None))
+        # end logging
+        await asyncio.gather(stdout_log_process, stderr_log_process)
 
     def get_cmd_script(self, *args: Any, **kwargs: Any) -> str:
         return self._create_cmd_script(self._cmd_path, self._cmd, *args, **kwargs)

zrb/task/docker_compose_start_task.py

@@ -45,6 +45,7 @@ class DockerComposeStartTask(DockerComposeTask):
         compose_options: Mapping[JinjaTemplate, JinjaTemplate] = {},
         compose_flags: Iterable[JinjaTemplate] = [],
         compose_args: Iterable[JinjaTemplate] = [],
+        compose_profiles: Iterable[JinjaTemplate] = [],
         compose_env_prefix: str = "",
         setup_cmd: CmdVal = "",
         setup_cmd_path: CmdVal = "",
@@ -85,9 +86,11 @@ class DockerComposeStartTask(DockerComposeTask):
             executable=executable,
             compose_service_configs=compose_service_configs,
             compose_file=compose_file,
+            compose_cmd="up",
             compose_options=compose_options,
             compose_flags=compose_flags,
             compose_args=compose_args,
+            compose_profiles=compose_profiles,
             compose_env_prefix=compose_env_prefix,
             setup_cmd=setup_cmd,
             setup_cmd_path=setup_cmd_path,
@@ -116,31 +119,31 @@ class DockerComposeStartTask(DockerComposeTask):
             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
+    def _get_execute_docker_compose_script(
+        self,
+        compose_cmd: JinjaTemplate,
+        compose_options: Mapping[JinjaTemplate, JinjaTemplate],
+        compose_flags: Iterable[JinjaTemplate],
+        compose_args: Iterable[JinjaTemplate],
+        *args: Any
+    ) -> JinjaTemplate:
+        return "\n".join(
+            [
+                # compose start
+                super()._get_execute_docker_compose_script(
+                    compose_cmd=compose_cmd,
+                    compose_options=compose_options,
+                    compose_flags=list(compose_flags) + ["-d"],
+                    compose_args=compose_args,
+                    *args,
+                ),
+                # compose log
+                super()._get_execute_docker_compose_script(
+                    compose_cmd="logs",
+                    compose_options={},
+                    compose_flags=["-f"],
+                    compose_args=[],
+                    *args,
+                ),
+            ]
         )
-        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

@@ -3,7 +3,6 @@ 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.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
@@ -33,32 +32,22 @@ from zrb.task_input.any_input import AnyInput
 
 logger.debug(colored("Loading zrb.task.docker_compose_task", attrs=["dark"]))
 
+TDockerComposeTask = TypeVar("TDockerComposeTask", bound="DockerComposeTask")
 
-def _get_ensure_zrb_network_task(backend: str):
-    CURRENT_DIR = os.path.dirname(__file__)
-    SHELL_SCRIPT_DIR = os.path.join(CURRENT_DIR, "..", "shell-scripts")
-    ensure_container_backend = CmdTask(
-        name="ensure-compose-backend",
-        cmd_path=[
-            os.path.join(SHELL_SCRIPT_DIR, "_common-util.sh"),
-            os.path.join(SHELL_SCRIPT_DIR, f"ensure-{backend}-is-installed.sh"),
-        ],
-        preexec_fn=None,
-        should_print_cmd_result=False,
-    )
-    return CmdTask(
-        name="ensure-zrb-network",
-        cmd=[
-            f"{backend} network inspect zrb >/dev/null 2>&1 || \\",
-            f"{backend} network create -d bridge zrb",
-        ],
-        upstreams=[ensure_container_backend],
-        should_print_cmd_result=False,
-    )
-
+CURRENT_DIR = os.path.dirname(__file__)
+SHELL_SCRIPT_DIR = os.path.join(CURRENT_DIR, "..", "shell-scripts")
 
-TDockerComposeTask = TypeVar("TDockerComposeTask", bound="DockerComposeTask")
-ensure_zrb_network_task = _get_ensure_zrb_network_task(CONTAINER_BACKEND)
+ensure_container_backend = CmdTask(
+    name="ensure-compose-backend",
+    cmd_path=[
+        os.path.join(SHELL_SCRIPT_DIR, "_common-util.sh"),
+        os.path.join(SHELL_SCRIPT_DIR, "ensure-docker-is-installed.sh"),
+    ],
+    preexec_fn=None,
+    should_print_cmd_result=False,
+    should_show_cmd=False,
+    should_show_working_directory=False,
+)
 
 
 @typechecked
@@ -93,6 +82,7 @@ class DockerComposeTask(CmdTask):
         compose_options: Mapping[JinjaTemplate, JinjaTemplate] = {},
         compose_flags: Iterable[JinjaTemplate] = [],
         compose_args: Iterable[JinjaTemplate] = [],
+        compose_profiles: CmdVal = "",
         compose_env_prefix: str = "",
         setup_cmd: CmdVal = "",
         setup_cmd_path: CmdVal = "",
@@ -120,21 +110,20 @@ class DockerComposeTask(CmdTask):
         should_show_cmd: bool = True,
         should_show_working_directory: bool = True,
     ):
-        combined_env_files = list(env_files)
         CmdTask.__init__(
             self,
             name=name,
             group=group,
             inputs=inputs,
             envs=envs,
-            env_files=combined_env_files,
+            env_files=env_files,
             icon=icon,
             color=color,
             description=description,
             executable=executable,
             cwd=cwd,
             should_render_cwd=should_render_cwd,
-            upstreams=[ensure_zrb_network_task] + upstreams,
+            upstreams=[ensure_container_backend] + upstreams,
             fallbacks=fallbacks,
             on_triggered=on_triggered,
             on_waiting=on_waiting,
@@ -168,6 +157,7 @@ class DockerComposeTask(CmdTask):
         self._compose_flags = compose_flags
         self._compose_args = compose_args
         self._compose_env_prefix = compose_env_prefix
+        self._compose_profiles = compose_profiles
         self._compose_template_file = self.__get_compose_template_file(compose_file)
         self._compose_runtime_file = self.__get_compose_runtime_file(
             self._compose_template_file
@@ -333,14 +323,24 @@ class DockerComposeTask(CmdTask):
         raise Exception(f"Invalid compose file: {compose_file}")
 
     def get_cmd_script(self, *args: Any, **kwargs: Any) -> str:
+        cmd_list = []
+        # create network
+        create_network_script = self._get_create_compose_network_script()
+        if create_network_script.strip() != "":
+            cmd_list.append(create_network_script)
+        # set compose profiles
+        compose_profile_script = self._get_compose_profile_script(*args, **kwargs)
+        if compose_profile_script.strip() != "":
+            cmd_list.append(compose_profile_script)
         # setup
-        setup_cmd = self._create_cmd_script(
+        setup_script = self._create_cmd_script(
             self._setup_cmd_path, self._setup_cmd, *args, **kwargs
         )
-        cmd_list = [setup_cmd] if setup_cmd.strip() != "" else []
+        if setup_script.strip() != "":
+            cmd_list.append(setup_script)
         # compose command
         cmd_list.append(
-            self._get_docker_compose_cmd_script(
+            self._get_execute_docker_compose_script(
                 compose_cmd=self._compose_cmd,
                 compose_options=self._compose_options,
                 compose_flags=self._compose_flags,
@@ -352,7 +352,38 @@ class DockerComposeTask(CmdTask):
         self.log_info(f"Command: {cmd_str}")
         return cmd_str
 
-    def _get_docker_compose_cmd_script(
+    def _get_compose_profile_script(self, *args, **kwargs) -> str:
+        # Get list representation of self._compose_profiles
+        compose_profiles = self._compose_profiles
+        if callable(compose_profiles):
+            compose_profiles = self._compose_profiles(*args, **kwargs)
+        if isinstance(compose_profiles, str):
+            compose_profiles = compose_profiles.split(",")
+        # Get only non empty profiles
+        filtered_compose_profiles = [
+            self.render_str(profile)
+            for profile in compose_profiles
+            if self.render_str(profile).strip() != ""
+        ]
+        if len(filtered_compose_profiles) == 0:
+            return ""
+        compose_profiles_str = ",".join(filtered_compose_profiles)
+        return f"export COMPOSE_PROFILES={compose_profiles_str}"
+
+    def _get_create_compose_network_script(self) -> str:
+        compose_data = read_compose_file(self._compose_runtime_file)
+        networks: Mapping[str, Mapping[str, Any]] = compose_data.get("networks", {})
+        scripts = []
+        for key, config in networks.items():
+            if not config.get("external", False):
+                continue
+            network_name = config.get("name", key)
+            scripts.append(
+                f"docker network inspect {network_name} > /dev/null 2>&1 || docker network create -d bridge{network_name}"  # noqa
+            )
+        return "\n".join(scripts)
+
+    def _get_execute_docker_compose_script(
         self,
         compose_cmd: str,
         compose_options: Mapping[JinjaTemplate, JinjaTemplate],
@@ -383,4 +414,4 @@ class DockerComposeTask(CmdTask):
                 if self.render_str(arg) != ""
             ]
         )
-        return f"{CONTAINER_BACKEND} compose {options} {compose_cmd} {flags} {args}"
+        return f"docker compose {options} {compose_cmd} {flags} {args}"

zrb/task/looper.py

@@ -1,4 +1,4 @@
-from collections.abc import Callable
+from collections.abc import Callable, Mapping
 from typing import Optional
 
 from zrb.helper.accessories.color import colored