zrb 0.0.85__py3-none-any.whl → 0.0.87__py3-none-any.whl

zrb/__init__.py

@@ -9,7 +9,8 @@ from .task.port_checker import PortChecker
 from .task.path_checker import PathChecker
 from .task.resource_maker import ResourceMaker, Replacement, ReplacementMutator
 from .task.flow_task import FlowTask, FlowNode
-from .task_input.input import Input
+from .task_input.any_input import AnyInput
+from .task_input.task_input import Input
 from .task_input.bool_input import BoolInput
 from .task_input.choice_input import ChoiceInput
 from .task_input.float_input import FloatInput
@@ -19,7 +20,7 @@ from .task_input.str_input import StrInput
 from .task_env.env import Env
 from .task_env.env_file import EnvFile
 from .task_group.group import Group
-from .builtin import _group as builtin_group
+from .builtin import group as builtin_group
 from .helper.default_env import inject_default_env
 
 
@@ -38,6 +39,7 @@ assert FlowTask
 assert FlowNode
 assert Replacement
 assert ReplacementMutator
+assert AnyInput
 assert Input
 assert BoolInput
 assert ChoiceInput

zrb/action/runner.py

@@ -1,4 +1,5 @@
 from typing import Any, Callable, Iterable, List, Mapping, Union
+from typeguard import typechecked
 from ..task_group.group import Group as TaskGroup
 from ..task.any_task import AnyTask
 import click
@@ -7,6 +8,7 @@ import sys
 CliSubcommand = Union[click.Group, click.Command]
 
 
+@typechecked
 class Runner():
     '''
     Runner class.
@@ -32,7 +34,9 @@ class Runner():
                 cli.add_command(subcommand)
         return cli
 
-    def _create_cli_subcommand(self, task: AnyTask) -> click.Group:
+    def _create_cli_subcommand(
+        self, task: AnyTask
+    ) -> Union[click.Group, click.Command]:
         subcommand: CliSubcommand = self._create_cli_command(task)
         task_group = task._group
         while task_group is not None:
@@ -82,9 +86,9 @@ class Runner():
         # if there are inputs with the same name, choose the first.
         registered_input: Mapping[str, bool] = {}
         for task_input in task_inputs:
-            if task_input.name in registered_input:
+            if task_input.get_name() in registered_input:
                 continue
-            registered_input[task_input.name] = True
+            registered_input[task_input.get_name()] = True
             param_decl = task_input.get_param_decl()
             options = task_input.get_options()
             command.params.append(click.Option(param_decl, **options))

zrb/builtin/__init__.py

@@ -1,41 +1,27 @@
+from . import group
 from . import base64
 from . import env
 from . import eval
 from . import git
 from . import md5
-from . import principle
+from . import explain
 from . import project
 from . import ubuntu
 from . import update
 from . import version
-from .devtool import devtool_install
-from .generator.project import create as generate_project
-from .generator.cmd_task import add as generate_cmd_task
-from .generator.docker_compose_task import add as generate_docker_compose_task
-from .generator.python_task import add as generate_python_task
-from .generator.simple_python_app import add as generate_simple_python_app
-from .generator.fastapp import add as generate_fastapp
-from .generator.fastapp_module import add as generate_fastapp_module
-from .generator.fastapp_crud import add as generate_fastapp_crud
-from .generator.fastapp_field import add as generate_fastapp_field
+from . import devtool
+from . import generator
 
+assert group
 assert base64
 assert env
 assert eval
 assert git
 assert md5
-assert principle
+assert explain
 assert project
 assert ubuntu
 assert update
 assert version
-assert devtool_install
-assert generate_project
-assert generate_cmd_task
-assert generate_docker_compose_task
-assert generate_python_task
-assert generate_simple_python_app
-assert generate_fastapp
-assert generate_fastapp_module
-assert generate_fastapp_crud
-assert generate_fastapp_field
+assert devtool
+assert generator

zrb/builtin/base64.py

@@ -1,5 +1,5 @@
 from typing import Any
-from ._group import base64_group
+from .group import base64_group
 from ..task.decorator import python_task
 from ..task_input.str_input import StrInput
 from ..runner import runner

zrb/builtin/devtool/__init__.py

@@ -0,0 +1,20 @@
+from .devtool_install import (
+    install_gvm, install_pyenv, install_nvm, install_sdkman, install_pulumi,
+    install_aws, install_gcloud, install_tmux, install_zsh, install_kubectl,
+    install_helm, install_docker, install_terraform, install_helix
+)
+
+assert install_gvm
+assert install_pyenv
+assert install_nvm
+assert install_sdkman
+assert install_pulumi
+assert install_aws
+assert install_gcloud
+assert install_tmux
+assert install_zsh
+assert install_kubectl
+assert install_helm
+assert install_docker
+assert install_terraform
+assert install_helix

zrb/builtin/devtool/devtool_install.py

@@ -1,12 +1,13 @@
 from typing import Any, Callable
+from typeguard import typechecked
 from ...config.config import get_current_shell
-from .._group import dev_tool_install_group
 from ...task.task import Task
 from ...task.flow_task import FlowTask, FlowNode
 from ...task_input.str_input import StrInput
 from ...task_input.bool_input import BoolInput
 from ...runner import runner
 from ...helper.file.text import read_text_file_async, write_text_file_async
+from ..group import dev_tool_install_group
 import os
 
 dir_path = os.path.dirname(__file__)
@@ -28,6 +29,7 @@ terminal_config_file_input = StrInput(
 ###############################################################################
 
 
+@typechecked
 def write_config(
     template_file: str, config_file: str, remove_old_config: bool = False
 ) -> Callable[..., Any]:
@@ -39,7 +41,8 @@ def write_config(
         rendered_template_file = os.path.expandvars(os.path.expanduser(
             task.render_str(template_file)
         ))
-        if remove_old_config:
+        if remove_old_config and os.path.exists(rendered_config_file):
+            task.print_out(f'Removing {rendered_config_file}')
             os.remove(rendered_config_file)
         additional_content = await read_text_file_async(
             rendered_template_file
@@ -48,6 +51,7 @@ def write_config(
         if os.path.exists(rendered_config_file):
             content = await read_text_file_async(rendered_config_file) + '\n'
         new_content = content + additional_content
+        task.print_out(f'Writing content to {rendered_config_file}')
         await write_text_file_async(rendered_config_file, new_content)
     return set_config
 
@@ -409,3 +413,42 @@ install_terraform = FlowTask(
     retry=0
 )
 runner.register(install_terraform)
+
+install_helix = FlowTask(
+    name='helix',
+    group=dev_tool_install_group,
+    description='Post modern text editor',
+    nodes=[
+        FlowNode(
+            name='install-helix',
+            cmd_path=os.path.join(dir_path, 'helix', 'install.sh'),
+            preexec_fn=None
+        ),
+        [
+            FlowNode(
+                name='create-helix-theme',
+                run=write_config(
+                    template_file=os.path.join(
+                        dir_path, 'helix', 'resource', 'themes', 'gruvbox_transparent.toml' # noqa
+                    ),
+                    config_file='~/.config/helix/themes/gruvbox_transparent.toml', # noqa
+                    remove_old_config=True
+                ),
+                preexec_fn=None
+            ),
+            FlowNode(
+                name='configure-helix',
+                run=write_config(
+                    template_file=os.path.join(
+                        dir_path, 'helix', 'resource', 'config.toml'
+                    ),
+                    config_file='~/.config/helix/config.toml',
+                    remove_old_config=True
+                ),
+                preexec_fn=None
+            ),
+        ],
+    ],
+    retry=0
+)
+runner.register(install_helix)

zrb/builtin/devtool/docker/install.sh

@@ -1,4 +1,12 @@
+set +e
+apt --version
+if [ "$?" != 0 ]
+then
+    >&2 echo "apt not found"
+    exit 1
+fi
 set -e
+
 curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
 sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
 sudo apt-get update

zrb/builtin/devtool/gcloud/install.sh

@@ -1,4 +1,12 @@
+set +e
+apt --version
+if [ "$?" != 0 ]
+then
+    >&2 echo "apt not found"
+    exit 1
+fi
 set -e
+
 echo "deb [signed-by=/usr/share/keyrings/cloud.google.gpg] https://packages.cloud.google.com/apt cloud-sdk main" | sudo tee -a /etc/apt/sources.list.d/google-cloud-sdk.list
 sudo apt-get install apt-transport-https ca-certificates gnupg
 curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key --keyring /usr/share/keyrings/cloud.google.gpg add -

zrb/builtin/devtool/helix/install.sh

@@ -0,0 +1,20 @@
+set -e
+if [ "{{ platform.system() }}" = "Darwin" ]
+then
+    sudo brew install helix
+elif [ "{{ platform.system() }}" = "Linux" ]
+then
+    set +e
+    apt --version
+    if [ "$?" != 0 ]
+    then
+        >&2 echo "apt not found"
+        exit 1
+    fi
+    set -e
+    sudo add-apt-repository ppa:maveonair/helix-editor -y
+    sudo apt update
+    sudo apt install helix
+else
+    echo "Cannot determine how to install zsh, assuming it has been installed"
+fi

zrb/builtin/devtool/helix/resource/config.toml

@@ -0,0 +1,10 @@
+theme = "gruvbox_transparent"
+
+[editor]
+line-number = "relative"
+mouse = true
+
+[editor.cursor-shape]
+insert = "bar"
+normal = "block"
+select = "underline"

zrb/builtin/devtool/helix/resource/themes/gruvbox_transparent.toml

@@ -0,0 +1,2 @@
+inherits = "gruvbox"
+"ui.background" = { }

zrb/builtin/devtool/tmux/install.sh

@@ -4,6 +4,14 @@ then
     sudo brew install tmux
 elif [ "{{ platform.system() }}" = "Linux" ]
 then
+    set +e
+    apt --version
+    if [ "$?" != 0 ]
+    then
+        >&2 echo "apt not found"
+        exit 1
+    fi
+    set -e
     sudo apt install tmux
 else
     echo "Cannot determine how to install tmux, assuming it has been installed"

zrb/builtin/devtool/zsh/install.sh

@@ -1,8 +1,17 @@
+set -e
 if [ "{{ platform.system() }}" = "Darwin" ]
 then
     sudo brew install zsh
 elif [ "{{ platform.system() }}" = "Linux" ]
 then
+    set +e
+    apt --version
+    if [ "$?" != 0 ]
+    then
+        >&2 echo "apt not found"
+        exit 1
+    fi
+    set -e
     sudo apt install zsh
 else
     echo "Cannot determine how to install zsh, assuming it has been installed"

zrb/builtin/devtool/zsh/resource/config.sh

@@ -129,3 +129,5 @@ KUBE_PS1_PREFIX=''
 KUBE_PS1_SUFFIX=' '
 KUBE_PS1_CTX_COLOR=cyan
 PROMPT='$(kube_ps1)'$PROMPT
+
+export COLORTERM=truecolor

zrb/builtin/env.py

@@ -1,5 +1,5 @@
-from typing import Any, Mapping
-from ._group import env_group
+from typing import Any, List
+from .group import env_group
 from ..helper.accessories.color import colored
 from ..task.decorator import python_task
 from ..task.task import Task
@@ -22,9 +22,12 @@ async def get(*args: Any, **kwargs: Any):
     names = list(env_map.keys())
     names.sort()
     colored_equal = colored('=', color='grey', attrs=['dark'])
+    env_lines: List[str] = []
     for name in names:
         value = env_map[name]
         colored_name = colored(name, color='green', attrs=['bold'])
         colored_value = colored(value, attrs=['bold'])
-        task.print_out(f'{colored_name}{colored_equal}{colored_value}')
+        env_lines.append(f'{colored_name}{colored_equal}{colored_value}')
+    line_separator = '\n    '
+    task.print_out(line_separator + line_separator.join(env_lines))
     return env_map

zrb/builtin/explain.py

@@ -0,0 +1,129 @@
+from typing import Any
+from typeguard import typechecked
+from .group import explain_group
+from ..task.decorator import python_task
+from ..task.task import Task
+from ..runner import runner
+
+
+@typechecked
+def show_lines(task: Task, *lines: str):
+    separator = '\n    '
+    task.print_out(
+        '\n' + separator + separator.join(lines) + '\n', trim_message=False
+    )
+
+
+###############################################################################
+# Task Definitions
+###############################################################################
+
+
+@python_task(
+    name='solid',
+    group=explain_group,
+    description='Explain SOLID principle',
+    runner=runner
+)
+async def explain_solid(*args: Any, **kwargs: Any):
+    show_lines(
+        kwargs['_task'],
+        'S - Single Responsibility Principle',
+        'O - Open/Closed Principle',
+        'L - Liskov’s Substitution Principle',
+        'I - Interface Segregation Principle',
+        'D - Dependency Inversion Principle',
+        '',
+        'In software development, Object-Oriented Design plays a crucial role when it comes to writing flexible, scalable, maintainable, and reusable code. There are so many benefits of using OOD but every developer should also have the knowledge of the SOLID principle for good object-oriented design in programming. The SOLID principle was introduced by Robert C. Martin, also known as Uncle Bob and it is a coding standard in programming.', # noqa
+        '',
+        'The SOLID principle helps in reducing tight coupling. Tight coupling means a group of classes are highly dependent on one another which you should avoid in your code. Opposite of tight coupling is loose coupling and your code is considered as a good code when it has loosely-coupled classes. Loosely coupled classes minimize changes in your code, helps in making code more reusable, maintainable, flexible and stable.', # noqa
+    )
+
+
+@python_task(
+    name='yagni',
+    group=explain_group,
+    description='Explain YAGNI principle',
+    runner=runner
+)
+async def explain_yagni(*args: Any, **kwargs: Any):
+    show_lines(
+        kwargs['_task'],
+        'Y - You',
+        'A - Aren\'t',
+        'G - Gonna',
+        'N - Need',
+        'I - It',
+        '',
+        'YAGNI principle ("You Aren\'t Gonna Need It") is a practice in software development which states that features should only be added when required.', # noqa
+        '',
+        'As a part of the extreme programming (XP) philosophy, YAGNI trims away excess and inefficiency in development to facilitate the desired increased frequency of releases.', # noqa
+    )
+
+
+@python_task(
+    name='dry',
+    group=explain_group,
+    description='Explain DRY principle',
+    runner=runner
+)
+async def explain_dry(*args: Any, **kwargs: Any):
+    show_lines(
+        kwargs['_task'],
+        'D - Don\'t',
+        'R - Repeat',
+        'Y - Yourself',
+        '',
+        '"Don\'t repeat yourself" (DRY) is a principle of software development aimed at reducing repetition of information which is likely to change, replacing it with abstractions that are less likely to change, or using data normalization which avoids redundancy in the first place.', # noqa
+        '',
+        'The DRY principle is stated as "Every piece of knowledge must have a single, unambiguous, authoritative representation within a system". The principle has been formulated by Andy Hunt and Dave Thomas in their book The Pragmatic Programmer.', # noqa
+    )
+
+
+@python_task(
+    name='kiss',
+    group=explain_group,
+    description='Explain KISS principle',
+    runner=runner
+)
+async def explain_kiss(*args: Any, **kwargs: Any):
+    show_lines(
+        kwargs['_task'],
+        'K - Keep',
+        'I - It',
+        'S - Simple',
+        'S - Stupid',
+        '',
+        'KISS, an acronym for "Keep it simple, stupid!", is a design principle noted by the U.S. Navy in 1960. First seen partly in American English by at least 1938, the KISS principle states that most systems work best if they are kept simple rather than made complicated; therefore, simplicity should be a key goal in design, and unnecessary complexity should be avoided.' # noqa
+    )
+
+
+@python_task(
+    name='zen-of-python',
+    group=explain_group,
+    description='Explain Zen of Python',
+    runner=runner
+)
+async def explain_zen_of_python(*args: Any, **kwargs: Any):
+    show_lines(
+        kwargs['_task'],
+        'Beautiful is better than ugly.',
+        'Explicit is better than implicit.',
+        'Simple is better than complex.',
+        'Complex is better than complicated.',
+        'Flat is better than nested.',
+        'Sparse is better than dense.',
+        'Readability counts.',
+        'Special cases aren\'t special enough to break the rules.',
+        'Although practicality beats purity.',
+        'Errors should never pass silently.',
+        'Unless explicitly silenced.',
+        'In the face of ambiguity, refuse the temptation to guess.',
+        'There should be one-- and preferably only one --obvious way to do it.', # noqa
+        'Although that way may not be obvious at first unless you\'re Dutch.',
+        'Now is better than never.',
+        'Although never is often better than *right* now.',
+        'If the implementation is hard to explain, it\'s a bad idea.',
+        'If the implementation is easy to explain, it may be a good idea.',
+        'Namespaces are one honking great idea -- let\'s do more of those!',
+    )

zrb/builtin/generator/__init__.py

@@ -0,0 +1,27 @@
+from . import common
+from . import project_task
+from .project.create import create_project
+from .cmd_task.add import add_cmd_task
+from .docker_compose_task.add import add_docker_compose_task
+from .python_task.add import add_python_task
+from .simple_python_app import add as add_simple_python_app
+from .fastapp import add as add_fastapp
+from .fastapp_module import add as add_fastapp_module
+from .fastapp_crud import add as add_fastapp_crud
+from .fastapp_field import add as add_fastapp_field
+from .pip_package import add as add_pip_package
+from .app_generator import add as add_app_generator
+
+assert common
+assert project_task
+assert create_project
+assert add_cmd_task
+assert add_docker_compose_task
+assert add_python_task
+assert add_simple_python_app
+assert add_fastapp
+assert add_fastapp_module
+assert add_fastapp_crud
+assert add_fastapp_field
+assert add_pip_package
+assert add_app_generator

zrb/builtin/generator/app_generator/add.py

@@ -0,0 +1,81 @@
+from typing import Any
+from ..common.task_input import project_dir_input
+from ..common.helper import (
+    validate_existing_project_dir, validate_inexisting_automation
+)
+from ..common.task_factory import create_register_module
+from ...group import project_add_group
+from ....task.decorator import python_task
+from ....task.task import Task
+from ....task.resource_maker import ResourceMaker
+from ....task_input.str_input import StrInput
+from ....helper.accessories.name import get_random_name
+from ....runner import runner
+
+import os
+
+CURRENT_DIR = os.path.dirname(__file__)
+
+
+template_name_input = StrInput(
+    name='template-name',
+    shortcut='t',
+    description='Template name',
+    prompt='Template name',
+    default=get_random_name()
+)
+
+
+###############################################################################
+# Task Definitions
+###############################################################################
+
+
+@python_task(
+    name='validate',
+    inputs=[
+        project_dir_input,
+        template_name_input
+    ]
+)
+async def validate(*args: Any, **kwargs: Any):
+    project_dir = kwargs.get('project_dir')
+    validate_existing_project_dir(project_dir)
+    template_name = kwargs.get('template_name')
+    validate_inexisting_automation(project_dir, template_name)
+
+
+copy_resource = ResourceMaker(
+    name='copy-resource',
+    inputs=[
+        project_dir_input,
+        template_name_input,
+    ],
+    upstreams=[validate],
+    replacements={
+        'zrbMetaTemplateName': '{{input.template_name}}',
+    },
+    template_path=os.path.join(CURRENT_DIR, 'template'),
+    destination_path='{{ input.project_dir }}',
+    excludes=[
+        '*/__pycache__',
+    ]
+)
+
+register_module = create_register_module(
+    module_path='_automate.{{util.to_snake_case(input.template_name)}}.add',
+    alias='{{util.to_snake_case(input.template_name)}}_add',
+    inputs=[template_name_input],
+    upstreams=[copy_resource]
+)
+
+
+@python_task(
+    name='app-generator',
+    group=project_add_group,
+    upstreams=[register_module],
+    runner=runner
+)
+async def add_python_task(*args: Any, **kwargs: Any):
+    task: Task = kwargs.get('_task')
+    task.print_out('Success')