zrb 0.28.0__py3-none-any.whl → 1.0.0a1__py3-none-any.whl

zrb/__init__.py

@@ -1,103 +1,96 @@
-from zrb.helper.default_env import inject_default_env
-from zrb.runner import runner
-from zrb.task.any_task import AnyTask
-from zrb.task.any_task_event_handler import (
-    OnFailed,
-    OnReady,
-    OnRetry,
-    OnSkipped,
-    OnStarted,
-    OnTriggered,
-    OnWaiting,
+from .attr.type import (
+    AnyAttr,
+    BoolAttr,
+    FloatAttr,
+    IntAttr,
+    StrAttr,
+    StrDictAttr,
+    fstring,
 )
-from zrb.task.checker import Checker
-from zrb.task.cmd_task import CmdTask
-from zrb.task.decorator import python_task
-from zrb.task.docker_compose_start_task import DockerComposeStartTask
-from zrb.task.docker_compose_task import DockerComposeTask, ServiceConfig
-from zrb.task.flow_task import FlowTask
-from zrb.task.http_checker import HTTPChecker
-from zrb.task.notifier import Notifier
-from zrb.task.parallel import AnyParallel, Parallel
-from zrb.task.path_checker import PathChecker
-from zrb.task.path_watcher import PathWatcher
-from zrb.task.port_checker import PortChecker
-from zrb.task.recurring_task import RecurringTask
-from zrb.task.remote_cmd_task import RemoteCmdTask
-from zrb.task.resource_maker import (
-    Replacement,
-    ReplacementMutator,
-    ResourceMaker,
-    get_default_resource_excludes,
-    get_default_resource_skip_parsing,
-)
-from zrb.task.rsync_task import RsyncTask
-from zrb.task.server import Controller, Server
-from zrb.task.task import Task
-from zrb.task.time_watcher import TimeWatcher
-from zrb.task.watcher import Watcher
-from zrb.task.wiki_task import create_wiki_tasks
-from zrb.task_env.env import Env
-from zrb.task_env.env_file import EnvFile
-from zrb.task_group.group import Group
-from zrb.task_input.any_input import AnyInput
-from zrb.task_input.bool_input import BoolInput
-from zrb.task_input.choice_input import ChoiceInput
-from zrb.task_input.float_input import FloatInput
-from zrb.task_input.int_input import IntInput
-from zrb.task_input.multiline_input import MultilineInput
-from zrb.task_input.password_input import PasswordInput
-from zrb.task_input.str_input import StrInput
-from zrb.task_input.task_input import Input
+from .callback.any_callback import AnyCallback
+from .callback.callback import Callback
+from .cmd.cmd_result import CmdResult
+from .cmd.cmd_val import Cmd, CmdPath
+from .config import SHOULD_LOAD_BUILTIN
+from .content_transformer.any_content_transformer import AnyContentTransformer
+from .content_transformer.content_transformer import ContentTransformer
+from .context.any_context import AnyContext
+from .context.any_shared_context import AnySharedContext
+from .context.context import Context
+from .context.shared_context import SharedContext
+from .env.any_env import AnyEnv
+from .env.env import Env
+from .env.env_file import EnvFile
+from .env.env_map import EnvMap
+from .group.any_group import AnyGroup
+from .group.group import Group
+from .input.any_input import AnyInput
+from .input.base_input import BaseInput
+from .input.int_input import IntInput
+from .input.password_input import PasswordInput
+from .input.str_input import StrInput
+from .input.text_input import TextInput
+from .runner.cli import cli
+from .session.session import Session
+from .task.any_task import AnyTask
+from .task.base_task import BaseTask
+from .task.base_trigger import BaseTrigger
+from .task.cmd_task import CmdTask
+from .task.http_check import HttpCheck
+from .task.make_task import make_task
+from .task.rsync_task import RsyncTask
+from .task.scaffolder import Scaffolder
+from .task.scheduler import Scheduler
+from .task.task import Task
+from .task.tcp_check import TcpCheck
+from .xcom.xcom import Xcom
 
-assert create_wiki_tasks
-assert runner
-assert AnyTask
-assert OnTriggered
-assert OnWaiting
-assert OnSkipped
-assert OnStarted
-assert OnReady
-assert OnRetry
-assert OnFailed
-assert AnyParallel
-assert Parallel
-assert python_task
-assert Task
-assert CmdTask
-assert DockerComposeTask
-assert DockerComposeStartTask
-assert ServiceConfig
-assert RemoteCmdTask
-assert RsyncTask
-assert Notifier
-assert Checker
-assert HTTPChecker
-assert PortChecker
-assert PathChecker
-assert PathWatcher
-assert Controller
-assert Server
-assert Watcher
-assert TimeWatcher
-assert ResourceMaker
-assert FlowTask
-assert RecurringTask
-assert get_default_resource_excludes
-assert get_default_resource_skip_parsing
-assert Replacement
-assert ReplacementMutator
+assert fstring
+assert AnyAttr
+assert BoolAttr
+assert IntAttr
+assert FloatAttr
+assert StrAttr
+assert StrDictAttr
+assert AnyCallback
+assert Callback
+assert AnyEnv
+assert Env
+assert EnvFile
+assert EnvMap
 assert AnyInput
-assert Input
-assert BoolInput
-assert ChoiceInput
-assert FloatInput
+assert BaseInput
+assert Cmd
+assert CmdPath
+assert CmdResult
+assert CmdTask
+assert HttpCheck
+assert TcpCheck
 assert IntInput
-assert MultilineInput
 assert PasswordInput
 assert StrInput
-assert Env
-assert EnvFile
+assert TextInput
+assert AnyGroup
 assert Group
+assert AnyTask
+assert BaseTask
+assert BaseTrigger
+assert RsyncTask
+assert Task
+assert Session
+assert AnyContext
+assert Context
+assert AnySharedContext
+assert SharedContext
+assert make_task
+assert AnyContentTransformer
+assert ContentTransformer
+assert Scaffolder
+assert Scheduler
+assert cli
+assert Xcom
+
+if SHOULD_LOAD_BUILTIN:
+    from . import builtin
 
-inject_default_env()
+    assert builtin

zrb/__main__.py

@@ -1,8 +1,12 @@
-from zrb.helper.cli import create_cli
-from zrb.helper.default_env import inject_default_env
+import sys
 
-inject_default_env()
-cli = create_cli()
+from .runner.cli import cli
+from .util.cli.style import stylize_error
+from .util.group import NodeNotFoundError
 
-if __name__ == "__main__":
-    cli()
+
+def serve_cli():
+    try:
+        cli.run(sys.argv[1:])
+    except NodeNotFoundError as e:
+        print(stylize_error(f"{e}"), file=sys.stderr)

zrb/attr/type.py

@@ -0,0 +1,11 @@
+from typing import Any, Callable
+
+from ..context.any_shared_context import AnySharedContext
+
+fstring = str
+AnyAttr = Any | fstring | Callable[[AnySharedContext], Any]
+StrAttr = str | fstring | Callable[[AnySharedContext], str]
+BoolAttr = bool | fstring | Callable[[AnySharedContext], bool]
+IntAttr = int | fstring | Callable[[AnySharedContext], int]
+FloatAttr = float | fstring | Callable[[AnySharedContext], float]
+StrDictAttr = dict[str, StrAttr] | Callable[[AnySharedContext], dict[str, Any]]

zrb/builtin/__init__.py

@@ -1,135 +1,3 @@
-from zrb.builtin.base64 import base64_group, decode_base64, encode_base64
-from zrb.builtin.devtool import (
-    devtool_group,
-    devtool_install_group,
-    install_aws,
-    install_docker,
-    install_gcloud,
-    install_gvm,
-    install_helix,
-    install_helm,
-    install_kubectl,
-    install_nvm,
-    install_pulumi,
-    install_pyenv,
-    install_sdkman,
-    install_selenium,
-    install_terraform,
-    install_tmux,
-    install_zsh,
-)
-from zrb.builtin.docker import docker_group, prune_docker
-from zrb.builtin.env import env_group, get_env
-from zrb.builtin.eval import evaluate
-from zrb.builtin.explain import explain_group, explain_tasks
-from zrb.builtin.git import clear_git_branch, get_git_file_changes, git_group
-from zrb.builtin.md5 import hash_text_md5, md5_group, sum_file_md5
-from zrb.builtin.monorepo import add_to_monorepo, pull_from_monorepo, push_to_monorepo
-from zrb.builtin.process import (
-    get_process_pid_by_name,
-    get_process_pid_by_port,
-    process_group,
-    process_pid_group,
-)
-from zrb.builtin.project import (
-    add_cmd_task,
-    add_docker_compose_task,
-    add_fastapp_application,
-    add_fastapp_crud,
-    add_fastapp_field,
-    add_fastapp_module,
-    add_plugin,
-    add_project_tasks,
-    add_python_app,
-    add_python_task,
-    create_project,
-    project_add_app_group,
-    project_add_fastapp_group,
-    project_add_group,
-    project_add_task_group,
-    project_group,
-)
-from zrb.builtin.say import say
-from zrb.builtin.schedule import schedule
-from zrb.builtin.ubuntu import (
-    install_ubuntu_all,
-    install_ubuntu_essentials,
-    install_ubuntu_tex,
-    install_ubuntu_toys,
-    ubuntu_group,
-    ubuntu_install_group,
-    update_ubuntu,
-)
-from zrb.builtin.update import update_zrb
-from zrb.builtin.version import get_version
-from zrb.builtin.watch_changes import watch_changes
+from . import shell
 
-assert base64_group
-assert decode_base64
-assert encode_base64
-assert devtool_group
-assert devtool_install_group
-assert install_aws
-assert install_docker
-assert install_gcloud
-assert install_gvm
-assert install_helix
-assert install_helm
-assert install_kubectl
-assert install_nvm
-assert install_pulumi
-assert install_pyenv
-assert install_sdkman
-assert install_selenium
-assert install_terraform
-assert install_tmux
-assert install_zsh
-assert docker_group
-assert prune_docker
-assert env_group
-assert get_env
-assert git_group
-assert clear_git_branch
-assert get_git_file_changes
-assert md5_group
-assert hash_text_md5
-assert sum_file_md5
-assert process_group
-assert process_pid_group
-assert get_process_pid_by_name
-assert get_process_pid_by_port
-assert project_group
-assert project_add_group
-assert project_add_app_group
-assert project_add_fastapp_group
-assert project_add_task_group
-assert create_project
-assert add_plugin
-assert add_fastapp_application
-assert add_fastapp_crud
-assert add_fastapp_module
-assert add_fastapp_field
-assert add_python_app
-assert add_project_tasks
-assert add_cmd_task
-assert add_docker_compose_task
-assert add_python_task
-assert add_to_monorepo
-assert pull_from_monorepo
-assert push_to_monorepo
-assert ubuntu_group
-assert ubuntu_install_group
-assert update_ubuntu
-assert ubuntu_install_group
-assert install_ubuntu_all
-assert install_ubuntu_essentials
-assert install_ubuntu_tex
-assert install_ubuntu_toys
-assert explain_group
-assert explain_tasks
-assert evaluate
-assert say
-assert schedule
-assert update_zrb
-assert get_version
-assert watch_changes
+assert shell

zrb/builtin/shell/__init__.py

@@ -0,0 +1,5 @@
+from . import autocomplete
+from ._group import shell_group
+
+assert autocomplete
+assert shell_group

zrb/builtin/shell/_group.py

@@ -0,0 +1,9 @@
+from ...group.group import Group
+from ...runner.cli import cli
+
+shell_group = cli.add_group(
+    Group(
+        name="shell",
+        description="Shell related commands",
+    )
+)

zrb/builtin/shell/autocomplete/__init__.py

@@ -0,0 +1,9 @@
+from ._group import shell_autocomplete_group
+from .bash import make_bash_autocomplete
+from .subcmd import get_shell_subcommands
+from .zsh import make_zsh_autocomplete
+
+assert shell_autocomplete_group
+assert make_bash_autocomplete
+assert make_zsh_autocomplete
+assert get_shell_subcommands

zrb/builtin/shell/autocomplete/_group.py

@@ -0,0 +1,6 @@
+from ....group.group import Group
+from .._group import shell_group
+
+shell_autocomplete_group: Group = shell_group.add_group(
+    Group(name="autocomplete", description="Shell autocomplete related commands")
+)

zrb/builtin/shell/autocomplete/bash.py

@@ -0,0 +1,41 @@
+from ....context.context import Context
+from ....task.make_task import make_task
+from ._group import shell_autocomplete_group
+
+_COMPLETION_SCRIPT = """
+# Bash dynamic completion script
+_zrb_complete() {
+    local cur cmd_input subcmd_output
+    local -a subcommands
+
+    # Get the current word being completed
+    cur="${COMP_WORDS[COMP_CWORD]}"
+
+    # Build the command input dynamically (excluding the current word being typed)
+    cmd_input="zrb shell autocomplete subcmd ${COMP_WORDS[@]:0:$COMP_CWORD}"
+
+    # Fetch the subcommands dynamically
+    subcmd_output=$(eval "$cmd_input 2>/dev/null")
+
+    # Split the output into an array of subcommands using whitespace
+    IFS=' ' read -r -a subcommands <<< "$subcmd_output"
+
+    # Generate completion suggestions if subcommands is not empty
+    COMPREPLY=( $(compgen -W "${subcommands[*]}" -- "$cur") )
+}
+
+# Register the completion function for zrb
+complete -F _zrb_complete zrb
+
+"""
+
+
+@make_task(
+    name="make-bash-autocomplete",
+    description="Create Zrb autocomplete script for bash",
+)
+def make_bash_autocomplete(ctx: Context):
+    return _COMPLETION_SCRIPT
+
+
+shell_autocomplete_group.add_task(make_bash_autocomplete, "bash")

zrb/builtin/shell/autocomplete/subcmd.py

@@ -0,0 +1,20 @@
+from ....context.context import Context
+from ....runner.cli import cli
+from ....task.make_task import make_task
+from ....util.cli.subcommand import get_group_subcommands
+from ._group import shell_autocomplete_group
+
+
+@make_task(
+    name="get-shell-subcommands",
+    description="Get subcommand of any Zrb command",
+)
+def get_shell_subcommands(ctx: Context):
+    subcommands = get_group_subcommands(cli)
+    for subcommand in subcommands:
+        if subcommand.paths == ctx.args:
+            return " ".join(subcommand.nexts)
+    return ""
+
+
+shell_autocomplete_group.add_task(get_shell_subcommands, "subcmd")

zrb/builtin/shell/autocomplete/zsh.py

@@ -0,0 +1,38 @@
+from ....context.context import Context
+from ....task.make_task import make_task
+from ._group import shell_autocomplete_group
+
+_COMPLETION_SCRIPT = """
+# Zsh dynamic completion script
+_zrb_complete() {
+    local -a subcommands
+    local cmd_input
+    local subcmd_output
+
+    # Build the command input based on the current words
+    cmd_input="zrb shell autocomplete subcmd ${words[1,CURRENT-1]}"
+
+    # Fetch the subcommands dynamically and store them in a variable
+    subcmd_output=$(eval "$cmd_input 2>/dev/null")
+
+    # Split the output into an array using spaces or newlines as separators
+    subcommands=(${=subcmd_output})
+
+    # Provide the completion suggestions
+    _describe 'subcommand' subcommands
+}
+
+# Register the completion function
+compdef _zrb_complete zrb
+"""
+
+
+@make_task(
+    name="make-zsh-autocomplete",
+    description="Create Zrb autocomplete script for zsh",
+)
+def make_zsh_autocomplete(ctx: Context):
+    return _COMPLETION_SCRIPT
+
+
+shell_autocomplete_group.add_task(make_zsh_autocomplete, "zsh")

zrb/callback/any_callback.py

@@ -0,0 +1,10 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+from ..context.any_shared_context import AnySharedContext
+
+
+class AnyCallback(ABC):
+    @abstractmethod
+    async def async_run(self, parent_ctx: AnySharedContext) -> Any:
+        pass

zrb/callback/callback.py

@@ -0,0 +1,28 @@
+from typing import Any
+
+from ..attr.type import StrDictAttr
+from ..session.any_session import AnySession
+from ..task.any_task import AnyTask
+from ..util.attr import get_str_dict_attr
+from .any_callback import AnyCallback
+
+
+class Callback(AnyCallback):
+
+    def __init__(
+        self,
+        input_mapping: StrDictAttr,
+        task: AnyTask,
+        auto_render: bool = True,
+    ):
+        self._input_mapping = input_mapping
+        self._task = task
+        self._auto_render = auto_render
+
+    async def async_run(self, session: AnySession) -> Any:
+        inputs = get_str_dict_attr(
+            session.shared_ctx, self._input_mapping, auto_render=self._auto_render
+        )
+        for name, value in inputs.items():
+            session.shared_ctx.input[name] = value
+        return await self._task.async_run(session)

zrb/cmd/cmd_result.py

@@ -0,0 +1,15 @@
+class CmdResult:
+    def __init__(self, output: str, error: str):
+        self.output = output
+        self.error = error
+
+    def __repr__(self):
+        class_name = self.__class__.__name__
+        last_line_output = self.output.split("\n")[-1]
+        shown_output = f"...{last_line_output}" if last_line_output != "" else ""
+        last_line_error = self.error.split("\n")[-1]
+        shown_error = f"...{last_line_error}" if last_line_error != "" else ""
+        return f"<{class_name} output={shown_output} error=...{shown_error}>"
+
+    def __str__(self) -> str:
+        return self.output

zrb/cmd/cmd_val.py

@@ -0,0 +1,35 @@
+from abc import ABC, abstractmethod
+from collections.abc import Callable
+
+from ..attr.type import fstring
+from ..context.context import Context
+
+
+class AnyCmdVal(ABC):
+    @abstractmethod
+    def to_str(self, ctx: Context) -> str:
+        pass
+
+
+class CmdPath(AnyCmdVal):
+    def __init__(self, path: str, auto_render: bool = True):
+        self._path = path
+        self._auto_render = auto_render
+
+    def to_str(self, ctx: Context) -> str:
+        file_path = ctx.render(self._path) if self._auto_render else self._path
+        with open(file_path) as file:
+            return file.read()
+
+
+class Cmd(AnyCmdVal):
+    def __init__(self, cmd: str, auto_render: str):
+        self._cmd = cmd
+        self._auto_render = auto_render
+
+    def to_str(self, ctx: Context) -> str:
+        return ctx.render(self._cmd) if self._auto_render else self._cmd
+
+
+SingleCmdVal = AnyCmdVal | fstring | Callable[[Context], str]
+CmdVal = SingleCmdVal | list[SingleCmdVal]

zrb/config.py

@@ -0,0 +1,72 @@
+import importlib.metadata as metadata
+import logging
+import os
+import platform
+
+from .util.string.conversion import to_boolean
+
+
+def _get_current_shell() -> str:
+    if platform.system() == "Windows":
+        return "PowerShell"
+    current_shell = os.getenv("SHELL", "")
+    if current_shell.endswith("zsh"):
+        return "zsh"
+    return "bash"
+
+
+def _get_log_level(level: str) -> int:
+    level = level.upper()
+    log_levels = {
+        "CRITICAL": logging.CRITICAL,  # 50
+        "ERROR": logging.ERROR,  # 40
+        "WARN": logging.WARNING,  # 30
+        "WARNING": logging.WARNING,  # 30
+        "INFO": logging.INFO,  # 20
+        "DEBUG": logging.DEBUG,  # 10
+        "NOTSET": logging.NOTSET,  # 0
+    }
+    if level in log_levels:
+        return log_levels[level]
+    return logging.WARNING
+
+
+DEFAULT_SHELL = os.getenv("ZRB_SHELL", _get_current_shell())
+DEFAULT_EDITOR = os.getenv("ZRB_EDITOR", "nano")
+INIT_MODULES_STR = os.getenv("ZRB_INIT_MODULES", "")
+INIT_MODULES = (
+    [module.strip() for module in INIT_MODULES_STR.split(":") if module.strip() != ""]
+    if INIT_MODULES_STR != ""
+    else []
+)
+INIT_SCRIPTS_STR = os.getenv("ZRB_INIT_SCRIPTS", "")
+INIT_SCRIPTS = (
+    [script.strip() for script in INIT_SCRIPTS_STR.split(":") if script.strip() != ""]
+    if INIT_SCRIPTS_STR != ""
+    else []
+)
+LOGGING_LEVEL = _get_log_level(os.getenv("ZRB_LOGGING_LEVEL", "WARNING"))
+SHOULD_LOAD_BUILTIN = to_boolean(os.getenv("ZRB_SHOULD_LOAD_BUILTIN", "1"))
+ENV_PREFIX = os.getenv("ZRB_ENV", "")
+SHOW_ADVERTISEMENT = to_boolean(os.getenv("ZRB_SHOW_ADVERTISEMENT", "1"))
+SHOW_PROMPT = to_boolean(os.getenv("ZRB_SHOW_PROMPT", "1"))
+SESSION_LOG_DIR = os.getenv(
+    "ZRB_SESSION_LOG_DIR", os.path.expanduser(os.path.join("~", ".zrb-session"))
+)
+VERSION = metadata.version("zrb")
+WEB_HTTP_PORT = int(os.getenv("ZRB_WEB_HTTP_PORT", "21213"))
+
+BANNER = f"""
+                bb
+   zzzzz rr rr  bb
+     zz  rrr  r bbbbbb
+    zz   rr     bb   bb
+   zzzzz rr     bbbbbb   {VERSION} Janggala
+   _ _ . .  . _ .  _ . . .
+
+A Framework to Enhance Your Workflow
+
+☕ Donate at: https://stalchmst.com/donation
+🐙 Submit issues/PR at: https://github.com/state-alchemists/zrb
+🐤 Follow us at: https://twitter.com/zarubastalchmst
+"""