zrb 0.28.0__tar.gz → 1.0.0a1__tar.gz

zrb-1.0.0a1/PKG-INFO

@@ -0,0 +1,140 @@
+Metadata-Version: 2.1
+Name: zrb
+Version: 1.0.0a1
+Summary: A Framework to Enhance Your Workflow
+Home-page: https://github.com/state-alchemists/zrb
+License: AGPL-3.0-or-later
+Keywords: Automation,Task Runner,Code Generator,Monorepo,Low Code
+Author: Go Frendi Gunawan
+Author-email: gofrendiasgard@gmail.com
+Requires-Python: >=3.10.0,<4.0.0
+Classifier: License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: autopep8 (>=2.0.4,<2.1.0)
+Requires-Dist: python-dotenv (>=1.0.1,<1.1.0)
+Requires-Dist: requests (>=2.32.3,<3.0.0)
+Requires-Dist: tomlkit (>=0.12.4,<0.13.0)
+Project-URL: Documentation, https://github.com/state-alchemists/zrb
+Project-URL: Repository, https://github.com/state-alchemists/zrb
+Description-Content-Type: text/markdown
+
+![](https://raw.githubusercontent.com/state-alchemists/zrb/main/_images/zrb/android-chrome-192x192.png)
+
+# 🤖 Zrb: Your Automation Powerhouse
+
+With Zrb, you can write your automation tasks like this:
+
+
+```python
+# Filename: zrb_init.py
+from zrb import cli, Task, Group, IntInput
+
+math = cli.add_group(Group("math", description="Math tools"))
+math.add_task(Task(
+    name="add",
+    input=[
+        IntInput("a", description="First number"),
+        IntInput("b", description="Second number")
+    ],
+    action=lambda ctx: ctx.input.a + ctx.input.b
+))
+```
+
+You can then access the task in various ways.
+
+__Using CLI with arguments__
+
+```bash
+zrb math add 4 5
+```
+
+Result:
+
+```
+9
+To run again: zrb math add --a=4 --b=5
+```
+
+__Using CLI with keyword arguments__
+
+```bash
+zrb math add --a 4 --b 5
+```
+
+Result:
+
+```
+9
+To run again: zrb math add --a=4 --b=5
+```
+
+__Using CLI with incomplete arguments__
+
+```bash
+zrb math add 4
+```
+
+Result:
+
+```
+b [0]: 5
+9
+To run again: zrb math add 4
+```
+
+__Using Web Interface__
+
+```bash
+zrb start-server
+```
+
+Result (you need to access `http://localhost:21213`)
+
+![](https://raw.githubusercontent.com/state-alchemists/zrb/refs/heads/1.0.0/_images/web.png)
+
+__More:__
+
+[![Video Title](https://img.youtube.com/vi/W7dgk96l__o/0.jpg)](https://www.youtube.com/watch?v=W7dgk96l__o)
+
+
+# 🫰 Installing Zrb
+
+You can install Zrb as a pip package by invoking the following command:
+
+```bash
+pip install --pre zrb
+```
+
+Alternatively, you can also use our installation script to install Zrb along with some prerequisites:
+
+```bash
+bash -c "$(curl -fsSL https://raw.githubusercontent.com/state-alchemists/zrb/main/install.sh)"
+```
+
+# 🐞 Bug Report + Feature Request
+
+You can submit bug reports and feature requests by creating a new [issue](https://github.com/state-alchemists/zrb/issues) on Zrb's GitHub Repositories. When reporting a bug or requesting a feature, please be sure to:
+
+- Include the version of Zrb you are using (i.e., `zrb version`)
+- Tell us what you have tried
+- Tell us what you expect
+- Tell us what you get
+
+We will also welcome your [pull requests and contributions](https://github.com/state-alchemists/zrb/pulls).
+
+
+# ☕ Donation
+
+Help Red Skull to click the donation button:
+
+[![](https://raw.githubusercontent.com/state-alchemists/zrb/main/_images/donator.png)](https://stalchmst.com/donation)
+
+# 🎉 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)
+

zrb-1.0.0a1/README.md

@@ -0,0 +1,116 @@
+![](https://raw.githubusercontent.com/state-alchemists/zrb/main/_images/zrb/android-chrome-192x192.png)
+
+# 🤖 Zrb: Your Automation Powerhouse
+
+With Zrb, you can write your automation tasks like this:
+
+
+```python
+# Filename: zrb_init.py
+from zrb import cli, Task, Group, IntInput
+
+math = cli.add_group(Group("math", description="Math tools"))
+math.add_task(Task(
+    name="add",
+    input=[
+        IntInput("a", description="First number"),
+        IntInput("b", description="Second number")
+    ],
+    action=lambda ctx: ctx.input.a + ctx.input.b
+))
+```
+
+You can then access the task in various ways.
+
+__Using CLI with arguments__
+
+```bash
+zrb math add 4 5
+```
+
+Result:
+
+```
+9
+To run again: zrb math add --a=4 --b=5
+```
+
+__Using CLI with keyword arguments__
+
+```bash
+zrb math add --a 4 --b 5
+```
+
+Result:
+
+```
+9
+To run again: zrb math add --a=4 --b=5
+```
+
+__Using CLI with incomplete arguments__
+
+```bash
+zrb math add 4
+```
+
+Result:
+
+```
+b [0]: 5
+9
+To run again: zrb math add 4
+```
+
+__Using Web Interface__
+
+```bash
+zrb start-server
+```
+
+Result (you need to access `http://localhost:21213`)
+
+![](https://raw.githubusercontent.com/state-alchemists/zrb/refs/heads/1.0.0/_images/web.png)
+
+__More:__
+
+[![Video Title](https://img.youtube.com/vi/W7dgk96l__o/0.jpg)](https://www.youtube.com/watch?v=W7dgk96l__o)
+
+
+# 🫰 Installing Zrb
+
+You can install Zrb as a pip package by invoking the following command:
+
+```bash
+pip install --pre zrb
+```
+
+Alternatively, you can also use our installation script to install Zrb along with some prerequisites:
+
+```bash
+bash -c "$(curl -fsSL https://raw.githubusercontent.com/state-alchemists/zrb/main/install.sh)"
+```
+
+# 🐞 Bug Report + Feature Request
+
+You can submit bug reports and feature requests by creating a new [issue](https://github.com/state-alchemists/zrb/issues) on Zrb's GitHub Repositories. When reporting a bug or requesting a feature, please be sure to:
+
+- Include the version of Zrb you are using (i.e., `zrb version`)
+- Tell us what you have tried
+- Tell us what you expect
+- Tell us what you get
+
+We will also welcome your [pull requests and contributions](https://github.com/state-alchemists/zrb/pulls).
+
+
+# ☕ Donation
+
+Help Red Skull to click the donation button:
+
+[![](https://raw.githubusercontent.com/state-alchemists/zrb/main/_images/donator.png)](https://stalchmst.com/donation)
+
+# 🎉 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)

{zrb-0.28.0 → zrb-1.0.0a1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "zrb"
-version = "0.28.0"
+version = "1.0.0a1"
 description = "A Framework to Enhance Your Workflow"
 authors = ["Go Frendi Gunawan <gofrendiasgard@gmail.com>"]
 license = "AGPL-3.0-or-later"
@@ -39,19 +39,10 @@ exclude = [
 
 [tool.poetry.dependencies]
 python = ">=3.10.0,<4.0.0"
-click = "~8.1.7"
-aiofiles = "~23.2.1"
-beartype = "~0.17.2"
-termcolor = "~2.4.0"
-Jinja2 = "~3.1.3"
-libcst = "~0.4.9"
 python-dotenv = "~1.0.1"
-jsons = "~1.6.3"
-"ruamel.yaml" = "~0.18.6"
-setuptools = "~70.0.0"
 autopep8 = "~2.0.4"
-croniter = "~2.0.2"
 tomlkit = "^0.12.4"
+requests = "^2.32.3"
 
 [tool.poetry.dev-dependencies]
 flake8 = "~7.0.0"
@@ -63,7 +54,7 @@ pytest-asyncio = "~0.21.0"
 flameprof = "~0.4"
 
 [tool.poetry.scripts]
-zrb = "zrb.__main__:cli"
+zrb = "zrb.__main__:serve_cli"
 
 [build-system]
 requires = ["poetry-core>=1.0.0"]

zrb-1.0.0a1/src/zrb/__init__.py

@@ -0,0 +1,96 @@
+from .attr.type import (
+    AnyAttr,
+    BoolAttr,
+    FloatAttr,
+    IntAttr,
+    StrAttr,
+    StrDictAttr,
+    fstring,
+)
+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 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 BaseInput
+assert Cmd
+assert CmdPath
+assert CmdResult
+assert CmdTask
+assert HttpCheck
+assert TcpCheck
+assert IntInput
+assert PasswordInput
+assert StrInput
+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
+
+    assert builtin

zrb-1.0.0a1/src/zrb/__main__.py

@@ -0,0 +1,12 @@
+import sys
+
+from .runner.cli import cli
+from .util.cli.style import stylize_error
+from .util.group import NodeNotFoundError
+
+
+def serve_cli():
+    try:
+        cli.run(sys.argv[1:])
+    except NodeNotFoundError as e:
+        print(stylize_error(f"{e}"), file=sys.stderr)

zrb-1.0.0a1/src/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-1.0.0a1/src/zrb/builtin/__init__.py

@@ -0,0 +1,3 @@
+from . import shell
+
+assert shell

zrb-1.0.0a1/src/zrb/builtin/shell/__init__.py

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

zrb-1.0.0a1/src/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-1.0.0a1/src/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-1.0.0a1/src/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-1.0.0a1/src/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-1.0.0a1/src/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-1.0.0a1/src/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-1.0.0a1/src/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-1.0.0a1/src/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-1.0.0a1/src/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-1.0.0a1/src/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]