zrb 0.10.0__py3-none-any.whl → 0.11.2__py3-none-any.whl

zrb/builtin/project/add/app/python/template/_automate/snake_zrb_app_name/image/__init__.py

@@ -0,0 +1,7 @@
+from ._group import snake_zrb_app_name_image_group
+from .build import build_snake_zrb_app_name_image
+from .push import push_snake_zrb_app_name_image
+
+assert snake_zrb_app_name_image_group
+assert build_snake_zrb_app_name_image
+assert push_snake_zrb_app_name_image

zrb/builtin/project/add/app/python/template/_automate/snake_zrb_app_name/image/_env.py

@@ -0,0 +1,7 @@
+from zrb import Env
+
+image_env = Env(
+    name="IMAGE",
+    os_name="CONTAINER_ZRB_ENV_PREFIX_IMAGE",
+    default="{{input.snake_zrb_app_name_image}}",
+)

zrb/builtin/project/add/app/python/template/_automate/snake_zrb_app_name/image/_group.py

@@ -0,0 +1,9 @@
+from zrb import Group
+
+from .._group import snake_zrb_app_name_group
+
+snake_zrb_app_name_image_group = Group(
+    name="image",
+    parent=snake_zrb_app_name_group,
+    description="Manage human readable zrb app name images",
+)

zrb/builtin/project/add/app/python/template/_automate/snake_zrb_app_name/image/_input.py

@@ -0,0 +1,8 @@
+from zrb import StrInput
+
+image_input = StrInput(
+    name="kebab-zrb-app-name-image",
+    description='Image name of "kebab-zrb-app-name"',
+    prompt='Image name of "kebab-zrb-app-name"',
+    default="zrb-app-image-name:latest",
+)

zrb/builtin/project/add/app/python/template/_automate/snake_zrb_app_name/image/build.py

@@ -0,0 +1,30 @@
+from zrb import DockerComposeTask, runner
+
+from ..._project import build_project, build_project_images
+from .._constant import RESOURCE_DIR
+from .._input import local_input
+from ._env import image_env
+from ._group import snake_zrb_app_name_image_group
+from ._input import image_input
+
+build_snake_zrb_app_name_image = DockerComposeTask(
+    icon="🏭",
+    name="build",
+    description="Build human readable zrb app name image",
+    group=snake_zrb_app_name_image_group,
+    inputs=[
+        local_input,
+        image_input,
+    ],
+    envs=[image_env],
+    should_execute="{{ input.local_snake_zrb_app_name}}",
+    cwd=RESOURCE_DIR,
+    compose_cmd="build",
+    compose_flags=["--no-cache"],
+    compose_env_prefix="CONTAINER_ZRB_ENV_PREFIX",
+)
+
+build_snake_zrb_app_name_image >> build_project_images
+build_snake_zrb_app_name_image >> build_project
+
+runner.register(build_snake_zrb_app_name_image)

zrb/builtin/project/add/app/python/template/_automate/snake_zrb_app_name/image/push.py

@@ -0,0 +1,30 @@
+from zrb import DockerComposeTask, runner
+
+from ..._project import publish_project, push_project_images
+from .._constant import RESOURCE_DIR
+from .._input import local_input
+from ._env import image_env
+from ._group import snake_zrb_app_name_image_group
+from ._input import image_input
+from .build import build_snake_zrb_app_name_image
+
+push_snake_zrb_app_name_image = DockerComposeTask(
+    icon="📰",
+    name="push",
+    description="Push human readable zrb app name image",
+    group=snake_zrb_app_name_image_group,
+    inputs=[
+        local_input,
+        image_input,
+    ],
+    envs=[image_env],
+    upstreams=[build_snake_zrb_app_name_image],
+    cwd=RESOURCE_DIR,
+    compose_cmd="push",
+    compose_env_prefix="CONTAINER_ZRB_ENV_PREFIX",
+)
+
+push_snake_zrb_app_name_image >> push_project_images
+push_snake_zrb_app_name_image >> publish_project
+
+runner.register(push_snake_zrb_app_name_image)

zrb/builtin/project/add/app/python/template/_automate/snake_zrb_app_name/start.py

@@ -0,0 +1,43 @@
+import os
+
+from zrb import CmdTask, Env, EnvFile, HTTPChecker, runner
+
+from .._project import start_project
+from ._constant import APP_DIR, APP_TEMPLATE_ENV_FILE_NAME
+from ._group import snake_zrb_app_name_group
+from ._input import host_input, https_input, local_input
+
+_CURRENT_DIR = os.path.dirname(__file__)
+
+
+start_snake_zrb_app_name = CmdTask(
+    icon="🚤",
+    name="start",
+    description="Start human readable zrb app name",
+    group=snake_zrb_app_name_group,
+    inputs=[local_input, host_input, https_input],
+    should_execute="{{ input.local_snake_zrb_app_name}}",
+    cwd=APP_DIR,
+    env_files=[EnvFile(path=APP_TEMPLATE_ENV_FILE_NAME, prefix="ZRB_ENV_PREFIX")],
+    envs=[
+        Env(
+            name="APP_PORT", os_name="ZRB_ENV_PREFIX_APP_PORT", default="zrbAppHttpPort"
+        )
+    ],
+    cmd_path=[
+        os.path.join(_CURRENT_DIR, "activate-venv.sh"),
+        os.path.join(_CURRENT_DIR, "start.sh"),
+    ],
+    checkers=[
+        HTTPChecker(
+            name="check-kebab-zrb-app-name",
+            host="{{input.snake_zrb_app_name_host}}",
+            port="{{env.APP_PORT}}",
+            is_https="{{input.snake_zrb_app_name_https}}",
+        )
+    ],
+)
+
+start_snake_zrb_app_name >> start_project
+
+runner.register(start_snake_zrb_app_name)

zrb/builtin/project/add/app/python/template/_automate/snake_zrb_app_name/start.sh

@@ -0,0 +1,6 @@
+PYTHONUNBUFFERED=1
+echo "Install packages"
+poetry install --no-root
+
+echo "Start app"
+poetry run uvicorn main:app --host {{env.get("APP_HOST", "0.0.0.0")}} --port {{env.get("APP_PORT", "8080")}}

zrb/builtin/project/add/app/python/template/src/kebab-zrb-app-name/deployment/__main__.py

@@ -0,0 +1,71 @@
+"""A Kubernetes Python Pulumi program to deploy kebab-zrb-app-name"""
+
+import os
+
+import pulumi
+import pulumi_kubernetes as k8s
+from dotenv import dotenv_values
+
+_CURRENT_DIR = os.path.dirname(__file__)
+_APP_DIR = os.path.join(os.path.dirname(_CURRENT_DIR), "src")
+_TEMPLATE_ENV_FILE_NAME = os.path.join(_APP_DIR, "template.env")
+
+image = os.getenv("IMAGE", "kebab-zrb-app-name:latest")
+replica = int(os.getenv("REPLICA", "1"))
+app_labels = {"app": "kebab-zrb-app-name"}
+env_map = dotenv_values(_TEMPLATE_ENV_FILE_NAME)
+app_port = int(os.getenv("APP_PORT", env_map.get("APP_PORT", "8080")))
+
+# Pulumi deployment docs:
+# https://www.pulumi.com/registry/packages/kubernetes/api-docs/apps/v1/deployment/
+deployment = k8s.apps.v1.Deployment(
+    resource_name="kebab-zrb-app-name",
+    spec=k8s.apps.v1.DeploymentSpecArgs(
+        selector=k8s.meta.v1.LabelSelectorArgs(match_labels=app_labels),
+        replicas=replica,
+        template=k8s.core.v1.PodTemplateSpecArgs(
+            metadata=k8s.meta.v1.ObjectMetaArgs(labels=app_labels),
+            spec=k8s.core.v1.PodSpecArgs(
+                containers=[
+                    k8s.core.v1.ContainerArgs(
+                        name="kebab-zrb-app-name",
+                        image=image,
+                        env=[
+                            k8s.core.v1.EnvVarArgs(
+                                name=env_name, value=os.getenv(env_name, default_value)
+                            )
+                            for env_name, default_value in env_map.items()
+                        ],
+                        ports=[k8s.core.v1.ContainerPortArgs(container_port=app_port)],
+                        liveness_probe=k8s.core.v1.ProbeArgs(
+                            http_get=k8s.core.v1.HTTPGetActionArgs(port=app_port)
+                        ),
+                        readiness_probe=k8s.core.v1.ProbeArgs(
+                            http_get=k8s.core.v1.HTTPGetActionArgs(port=app_port)
+                        ),
+                    )
+                ]
+            ),
+        ),
+    ),
+)
+
+# Pulumi services docs:
+# https://www.pulumi.com/registry/packages/kubernetes/api-docs/core/v1/service/
+service = k8s.core.v1.Service(
+    resource_name="kebab-zrb-app-name",
+    spec=k8s.core.v1.ServiceSpecArgs(
+        selector=app_labels,
+        ports=[
+            k8s.core.v1.ServicePortArgs(
+                port=app_port,
+                protocol="TCP",
+                target_port=app_port,
+            )
+        ],
+        type="LoadBalancer",
+    ),
+)
+
+pulumi.export("deployment-name", deployment.metadata["name"])
+pulumi.export("service-name", service.metadata["name"])

zrb/builtin/project/add/app/python/template/src/kebab-zrb-app-name/docker-compose.env

@@ -0,0 +1,3 @@
+CONTAINER_PREFIX=my
+HOST_PORT=zrbAppHttpPort
+APP_PORT=zrbAppHttpPort

zrb/builtin/project/add/app/python/template/src/kebab-zrb-app-name/src/.gitignore

@@ -0,0 +1,3 @@
+.env
+__pycache__
+.venv

zrb/builtin/project/add/app/python/template/src/kebab-zrb-app-name/src/pyproject.toml

@@ -0,0 +1,27 @@
+[tool.poetry]
+name = "kebab-zrb-app-name"
+version = "0.0.1"
+description = "zrbAppDescription"
+authors = ["zrbAppAuthorName <zrbAppAuthorEmail>"]
+keywords = []
+packages = [
+  {include = "kebab-zrb-project-name", from = ".."},
+]
+
+[tool.poetry.dependencies]
+python = ">=3.10.0,<4.0.0"
+uvicorn = "==0.20.0"
+
+[tool.poetry.dev-dependencies]
+flake8 = "~7.0.0"
+black = "~24.3.0"
+isort = "~5.13.2"
+pytest = "~7.4.0"
+pytest-cov = "~4.1.0"
+pytest-asyncio = "~0.21.0"
+flameprof = "~0.4"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"
+

zrb/builtin/project/add/app/python/template/src/kebab-zrb-app-name/src/template.env

@@ -0,0 +1,4 @@
+PYTHONUNBUFFERED=1
+APP_HOST=0.0.0.0
+APP_MESSAGE="Salve Mane"
+APP_PORT="zrbAppHttpPort"

zrb/builtin/project/add/fastapp/__init__.py

@@ -0,0 +1,11 @@
+from zrb.builtin.project.add.fastapp._group import project_add_fastapp_group
+from zrb.builtin.project.add.fastapp.app import add_fastapp_application
+from zrb.builtin.project.add.fastapp.crud import add_fastapp_crud
+from zrb.builtin.project.add.fastapp.field import add_fastapp_field
+from zrb.builtin.project.add.fastapp.module import add_fastapp_module
+
+assert project_add_fastapp_group
+assert add_fastapp_application
+assert add_fastapp_module
+assert add_fastapp_crud
+assert add_fastapp_field

zrb/builtin/project/add/fastapp/_group.py

@@ -0,0 +1,8 @@
+from zrb import Group
+from zrb.builtin.project.add._group import project_add_group
+
+project_add_fastapp_group = Group(
+    name="fastapp",
+    description="Add fastapp related resources",
+    parent=project_add_group,
+)

zrb/builtin/project/add/fastapp/app/__init__.py

@@ -0,0 +1,3 @@
+from zrb.builtin.project.add.fastapp.app.app import add_fastapp_application
+
+assert add_fastapp_application

zrb/builtin/project/add/fastapp/app/_input.py

@@ -0,0 +1,62 @@
+import os
+
+from zrb.task_input.int_input import IntInput
+from zrb.task_input.str_input import StrInput
+
+SYSTEM_USER = os.getenv("USER", "incognito")
+
+app_name_input = StrInput(
+    name="app-name",
+    shortcut="a",
+    description="App name",
+    prompt="App name",
+    default="app",
+)
+
+app_author_name_input = StrInput(
+    name="app-author-name",
+    prompt="App author name",
+    description="App author name",
+    default=SYSTEM_USER,
+)
+
+app_author_email_input = StrInput(
+    name="app-author-email",
+    prompt="App author email",
+    description="App author email",
+    default=f"{SYSTEM_USER}@gmail.com",
+)
+
+app_description_input = StrInput(
+    name="app-description",
+    description="App description",
+    prompt="App description",
+    default="Just another app",
+)
+
+app_image_default_namespace = os.getenv(
+    "PROJECT_IMAGE_DEFAULT_NAMESPACE", "docker.io/" + SYSTEM_USER
+)
+app_image_name_input = StrInput(
+    name="app-image-name",
+    description="App image name",
+    prompt="App image name",
+    default=app_image_default_namespace
+    + "/"
+    + "{{util.to_kebab_case(input.app_name)}}",  # noqa
+)
+
+http_port_input = IntInput(
+    name="http-port",
+    shortcut="p",
+    description="HTTP port",
+    prompt="HTTP port",
+    default=8080,
+)
+
+env_prefix_input = StrInput(
+    name="env-prefix",
+    description="OS environment prefix",
+    prompt="OS environment prefix",
+    default='{{util.to_snake_case(util.coalesce(input.app_name, input.task_name, "MY")).upper()}}',  # noqa
+)

zrb/builtin/project/add/fastapp/app/app.py

@@ -0,0 +1,123 @@
+import os
+
+from zrb.builtin.project._helper import (
+    create_register_module,
+    validate_existing_project_dir,
+    validate_inexisting_automation,
+)
+from zrb.builtin.project._input import project_dir_input
+from zrb.builtin.project.add.fastapp._group import project_add_fastapp_group
+from zrb.builtin.project.add.fastapp.app._input import (
+    app_author_email_input,
+    app_author_name_input,
+    app_description_input,
+    app_image_name_input,
+    app_name_input,
+    env_prefix_input,
+    http_port_input,
+)
+from zrb.helper.accessories.color import colored
+from zrb.helper.typing import Any
+from zrb.helper.util import to_kebab_case
+from zrb.runner import runner
+from zrb.task.decorator import python_task
+from zrb.task.resource_maker import ResourceMaker
+from zrb.task.task import Task
+
+_CURRENT_DIR = os.path.dirname(__file__)
+_snake_app_name_tpl = "{{util.to_snake_case(input.app_name)}}"
+
+
+@python_task(
+    name="validate",
+    inputs=[project_dir_input, app_name_input],
+)
+async def validate(*args: Any, **kwargs: Any):
+    project_dir = kwargs.get("project_dir")
+    validate_existing_project_dir(project_dir)
+    app_name = kwargs.get("app_name")
+    validate_inexisting_automation(project_dir, app_name)
+    source_dir = os.path.join(project_dir, "src", f"{to_kebab_case(app_name)}")
+    if os.path.exists(source_dir):
+        raise Exception(f"Source already exists: {source_dir}")
+
+
+copy_resource = ResourceMaker(
+    name="copy-resource",
+    inputs=[
+        project_dir_input,
+        app_name_input,
+        app_description_input,
+        app_author_name_input,
+        app_author_email_input,
+        app_image_name_input,
+        http_port_input,
+        env_prefix_input,
+    ],
+    upstreams=[validate],
+    replacements={
+        "zrbAppName": "{{input.app_name}}",
+        "zrbAppDescription": "{{input.app_description}}",
+        "zrbAppAuthorName": "{{input.app_author_name}}",
+        "zrbAppAuthorEmail": "{{input.app_author_email}}",
+        "zrbAppHttpPort": '{{util.coalesce(input.http_port, "3000")}}',
+        "ZRB_ENV_PREFIX": '{{util.coalesce(input.env_prefix, "MY").upper()}}',
+        "zrb-app-image-name": "{{input.app_image_name}}",
+        "zrbAppHttpAuthPort": '{{util.coalesce(input.http_port, "3001") + 1}}',
+        "zrbAppHttpLogPort": '{{util.coalesce(input.http_port, "3001") + 2}}',
+    },
+    template_path=os.path.join(_CURRENT_DIR, "template"),
+    destination_path="{{ input.project_dir }}",
+    excludes=[
+        "*/deployment/venv",
+        "*/__pycache__",
+        "*/src/kebab-zrb-app-name/.venv",
+        "*/src/kebab-zrb-app-name/src/frontend/node_modules",
+        "*/src/kebab-zrb-app-name/src/frontend/build",
+        "*/src/kebab-zrb-app-name/src/frontend/.svelte-kit",
+    ],
+    skip_parsing=[
+        "*.mp3",
+        "*.pdf",
+        "*.exe",
+        "*.dll",
+        "*.bin",
+        "*.iso",
+        "*.png",
+        "*.jpg",
+        "*.gif",
+        "*.ico",
+        "*/monitoring/clickhouse/user_scripts/histogramQuantile",
+    ],
+)
+
+register_module = create_register_module(
+    module_path=f"_automate.{_snake_app_name_tpl}",
+    alias=f"_automate_{_snake_app_name_tpl}",
+    inputs=[app_name_input],
+    upstreams=[copy_resource],
+)
+
+
+@python_task(
+    name="app",
+    group=project_add_fastapp_group,
+    description="Add Fastapp application",
+    inputs=[
+        project_dir_input,
+        app_name_input,
+        app_description_input,
+        app_author_name_input,
+        app_author_email_input,
+        app_image_name_input,
+        http_port_input,
+        env_prefix_input,
+    ],
+    upstreams=[
+        register_module,
+    ],
+    runner=runner,
+)
+async def add_fastapp_application(*args: Any, **kwargs: Any):
+    task: Task = kwargs.get("_task")
+    task.print_out(colored("Fastapp application added", color="yellow"))

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

@@ -0,0 +1,67 @@
+from ._group import snake_zrb_app_name_group
+from .backend import (
+    prepare_snake_zrb_app_name_backend,
+    snake_zrb_app_name_backend_group,
+)
+from .container import (
+    remove_snake_zrb_app_name_container,
+    snake_zrb_app_name_container_group,
+    snake_zrb_app_name_microservices_container_group,
+    snake_zrb_app_name_monolith_container_group,
+    snake_zrb_app_name_support_container_group,
+    start_snake_zrb_app_name_microservices_container,
+    start_snake_zrb_app_name_monolith_container,
+    start_snake_zrb_app_name_support_container,
+    stop_snake_zrb_app_name_container,
+)
+from .destroy import destroy_snake_zrb_app_name
+from .frontend import (
+    build_snake_zrb_app_name_frontend,
+    build_snake_zrb_app_name_frontend_once,
+    snake_zrb_app_name_frontend_group,
+)
+from .image import (
+    build_snake_zrb_app_name_image,
+    push_snake_zrb_app_name_image,
+    snake_zrb_app_name_image_group,
+)
+from .load_test import load_test_snake_zrb_app_name
+from .microservices import (
+    deploy_snake_zrb_app_name_microservices,
+    snake_zrb_app_name_microservices_group,
+    start_snake_zrb_app_name_microservices,
+)
+from .monolith import (
+    deploy_snake_zrb_app_name_monolith,
+    snake_zrb_app_name_monolith_group,
+    start_snake_zrb_app_name_monolith,
+)
+from .test import test_snake_zrb_app_name
+
+assert snake_zrb_app_name_group
+assert snake_zrb_app_name_backend_group
+assert snake_zrb_app_name_frontend_group
+assert snake_zrb_app_name_microservices_group
+assert snake_zrb_app_name_monolith_group
+assert snake_zrb_app_name_image_group
+assert snake_zrb_app_name_container_group
+assert snake_zrb_app_name_microservices_container_group
+assert snake_zrb_app_name_monolith_container_group
+assert snake_zrb_app_name_support_container_group
+assert destroy_snake_zrb_app_name
+assert start_snake_zrb_app_name_microservices
+assert deploy_snake_zrb_app_name_microservices
+assert start_snake_zrb_app_name_monolith
+assert deploy_snake_zrb_app_name_monolith
+assert remove_snake_zrb_app_name_container
+assert stop_snake_zrb_app_name_container
+assert start_snake_zrb_app_name_microservices_container
+assert start_snake_zrb_app_name_monolith_container
+assert start_snake_zrb_app_name_support_container
+assert build_snake_zrb_app_name_image
+assert push_snake_zrb_app_name_image
+assert build_snake_zrb_app_name_frontend_once
+assert build_snake_zrb_app_name_frontend
+assert prepare_snake_zrb_app_name_backend
+assert load_test_snake_zrb_app_name
+assert test_snake_zrb_app_name

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

@@ -0,0 +1,64 @@
+from zrb import HTTPChecker, PortChecker
+
+rabbitmq_management_checker = HTTPChecker(
+    name="check-rabbitmq-management",
+    port='{{env.get("RABBITMQ_MANAGEMENT_HOST_PORT", "15672")}}',
+    is_https="{{input.snake_zrb_app_name_https}}",
+    should_execute='{{env.get("APP_BROKER_TYPE", "rabbitmq") == "rabbitmq"}}',
+)
+
+rabbitmq_checker = PortChecker(
+    name="check-rabbitmq",
+    port='{{env.get("RABBITMQ_HOST_PORT", "5672")}}',
+    should_execute='{{env.get("APP_BROKER_TYPE", "rabbitmq") == "rabbitmq"}}',
+)
+
+redpanda_console_checker = HTTPChecker(
+    name="check-redpanda-console",
+    method="GET",
+    port='{{env.get("REDPANDA_CONSOLE_HOST_PORT", "9000")}}',
+    is_https="{{input.snake_zrb_app_name_https}}",
+    should_execute='{{env.get("APP_BROKER_TYPE", "rabbitmq") == "kafka"}}',
+)
+
+kafka_plaintext_checker = PortChecker(
+    name="check-kafka-plaintext",
+    port='{{env.get("KAFKA_INTERNAL_HOST_PORT", "29092")}}',
+    should_execute='{{env.get("APP_BROKER_TYPE", "rabbitmq") == "kafka"}}',
+)
+
+kafka_outside_checker = PortChecker(
+    name="check-kafka-outside",
+    port='{{env.get("KAFKA_EXTERNAL_HOST_PORT", "9092")}}',
+    should_execute='{{env.get("APP_BROKER_TYPE", "rabbitmq") == "kafka"}}',
+)
+
+pandaproxy_plaintext_checker = PortChecker(
+    name="check-pandaproxy-plaintext",
+    port='{{env.get("PANDAPROXY_INTERNAL_HOST_PORT", "29092")}}',
+    should_execute='{{env.get("APP_BROKER_TYPE", "rabbitmq") == "kafka"}}',
+)
+
+pandaproxy_outside_checker = PortChecker(
+    name="check-pandaproxy-outside",
+    port='{{env.get("PANDAPROXY_EXTERNAL_HOST_PORT", "9092")}}',
+    should_execute='{{env.get("APP_BROKER_TYPE", "rabbitmq") == "kafka"}}',
+)
+
+app_container_checker = HTTPChecker(
+    name="check-kebab-zrb-app-name-container",
+    host="{{input.snake_zrb_app_name_host}}",
+    url="/readiness",
+    port='{{env.get("HOST_PORT", "zrbAppHttpPort")}}',
+    is_https="{{input.snake_zrb_app_name_https}}",
+    should_execute="{{ input.local_snake_zrb_app_name}}",
+)
+
+app_local_checker = HTTPChecker(
+    name="check-kebab-zrb-app-name",
+    host="{{input.snake_zrb_app_name_host}}",
+    url="/readiness",
+    port='{{env.get("APP_PORT", "zrbAppHttpPort")}}',
+    is_https="{{input.snake_zrb_app_name_https}}",
+    should_execute="{{ input.local_snake_zrb_app_name}}",
+)

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

@@ -0,0 +1,25 @@
+import os
+
+import jsons
+
+from zrb.helper.string.conversion import to_boolean
+
+PREFER_MICROSERVICES = to_boolean(os.getenv("PROJECT_PREFER_MICROSERVICES", "0"))
+
+AUTOMATE_DIR = os.path.dirname(__file__)
+PROJECT_DIR = os.path.dirname(os.path.dirname(AUTOMATE_DIR))
+RESOURCE_DIR = os.path.join(PROJECT_DIR, "src", "kebab-zrb-app-name")
+DEPLOYMENT_DIR = os.path.join(RESOURCE_DIR, "deployment")
+DEPLOYMENT_TEMPLATE_ENV_FILE_NAME = os.path.join(DEPLOYMENT_DIR, "template.env")
+APP_DIR = os.path.join(RESOURCE_DIR, "src")
+APP_FRONTEND_DIR = os.path.join(APP_DIR, "frontend")
+APP_FRONTEND_BUILD_DIR = os.path.join(APP_FRONTEND_DIR, "build")
+APP_TEMPLATE_ENV_FILE_NAME = os.path.join(APP_DIR, "template.env")
+LOAD_TEST_DIR = os.path.join(RESOURCE_DIR, "loadtest")
+LOAD_TEST_TEMPLATE_ENV_FILE_NAME = os.path.join(RESOURCE_DIR, "template.env")
+
+MODULE_CONFIG_PATH = os.path.join(AUTOMATE_DIR, "config", "modules.json")
+
+with open(MODULE_CONFIG_PATH) as file:
+    MODULE_JSON_STR = file.read()
+MODULES = jsons.loads(MODULE_JSON_STR)