zrb 0.23.4__py3-none-any.whl → 0.24.0__py3-none-any.whl

zrb/builtin/project/add/fastapp/module/_helper/create_microservice_config.py

@@ -0,0 +1,158 @@
+import asyncio
+import os
+
+import jsons
+from dotenv import dotenv_values
+
+from zrb.helper.docker_compose.file import add_services
+from zrb.helper.file.text import (
+    append_text_file_async,
+    read_text_file_async,
+    write_text_file_async,
+)
+from zrb.helper.typecheck import typechecked
+from zrb.helper.typing import Any, List, Mapping
+from zrb.helper.util import to_kebab_case, to_snake_case
+from zrb.task.task import Task
+
+
+@typechecked
+async def create_microservice_config(
+    task: Task, project_dir: str, app_name: str, module_name: str
+):
+    modules = await _create_automation_json_config(
+        task, project_dir, app_name, module_name
+    )
+    return await asyncio.gather(
+        asyncio.create_task(
+            _add_docker_compose_service(
+                task, modules, project_dir, app_name, module_name
+            )
+        ),
+        asyncio.create_task(
+            _append_compose_env(task, modules, project_dir, app_name, module_name)
+        ),
+    )
+
+
+@typechecked
+async def _add_docker_compose_service(
+    task: Task, modules: List[str], project_dir: str, app_name: str, module_name: str
+):
+    kebab_app_name = to_kebab_case(app_name)
+    snake_module_name = to_snake_case(module_name)
+    upper_snake_module_name = snake_module_name.upper()
+    module_app_port = 8080 + len(modules)
+    module_app_port_str = str(module_app_port)
+    docker_compose_file_path = os.path.join(
+        project_dir, "src", kebab_app_name, "docker-compose.yml"
+    )
+    app_container_port_env_name = f"APP_{upper_snake_module_name}_MODULE_PORT"
+    app_container_port_env = (
+        "${" + app_container_port_env_name + ":-" + module_app_port_str + "}"
+    )  # noqa
+    app_host_port_env_name = f"APP_{upper_snake_module_name}_HOST_MODULE_PORT"
+    app_host_port_env = (
+        "${" + app_host_port_env_name + ":-" + module_app_port_str + "}"
+    )  # noqa
+    service_definition = _get_new_docker_compose_service_definition(
+        app_name=app_name,
+        module_name=module_name,
+        app_host_port_env=app_host_port_env,
+        app_container_port_env=app_container_port_env,
+    )
+    task.print_out(f"Add service at: {docker_compose_file_path}")
+    add_services(
+        file_name=docker_compose_file_path,
+        new_services=service_definition,
+    )
+
+
+@typechecked
+def _get_new_docker_compose_service_definition(
+    app_name: str, module_name: str, app_host_port_env: str, app_container_port_env: str
+) -> Mapping[str, Any]:
+    kebab_app_name = to_kebab_case(app_name)
+    kebab_module_name = to_kebab_case(module_name)
+    snake_module_name = to_snake_case(module_name)
+    upper_snake_module_name = snake_module_name.upper()
+    return {
+        f"{kebab_app_name}-{kebab_module_name}-service": {
+            "build": {"dockerfile": "Dockerfile", "context": "./src"},
+            "image": "${IMAGE:-" + kebab_app_name + "}",
+            "container_name": "${CONTAINER_PREFIX:-my}-"
+            + f"{kebab_app_name}-{kebab_module_name}-service",  # noqa
+            "hostname": f"{kebab_app_name}-{kebab_module_name}-service",
+            "env_file": ["src/template.env", "all-module-disabled.env"],
+            "environment": {
+                "APP_NAME": "${APP_NAME:-"
+                + kebab_app_name
+                + "}-"
+                + f"{kebab_module_name}-service",  # noqa
+                "APP_ENABLE_OTEL": "${APP_ENABLE_OTEL:-0}",
+                "APP_PORT": app_container_port_env,
+                "APP_ENABLE_EVENT_HANDLER": "true",
+                "APP_ENABLE_RPC_SERVER": "true",
+                "APP_ENABLE_API": "false",
+                "APP_ENABLE_FRONTEND": "false",
+                f"APP_ENABLE_{upper_snake_module_name}_MODULE": "true",
+            },
+            "ports": [f"{app_host_port_env}:{app_container_port_env}"],
+            "restart": "unless-stopped",
+            "profiles": ["microservices"],
+            "healthcheck": {
+                "test": f"curl --fail http://localhost:{app_container_port_env}/readiness || killall uvicorn",  # noqa
+                "interval": "20s",
+                "timeout": "3s",
+                "retries": 10,
+                "start_period": "20s",
+            },
+            "networks": ["zrb"],
+        }
+    }
+
+
+@typechecked
+async def _create_automation_json_config(
+    task: Task,
+    project_dir: str,
+    app_name: str,
+    module_name: str,
+):
+    snake_app_name = to_snake_case(app_name)
+    snake_module_name = to_snake_case(module_name)
+    json_modules_file_path = os.path.join(
+        project_dir, "_automate", snake_app_name, "config", "modules.json"
+    )
+    task.print_out(f"Read json config from: {json_modules_file_path}")
+    json_str = await read_text_file_async(json_modules_file_path)
+    task.print_out(f'Add "{snake_module_name}" to json config')
+    modules: List[str] = jsons.loads(json_str)
+    modules.append(snake_module_name)
+    json_str = jsons.dumps(modules)
+    task.print_out(f"Write new json config to: {json_modules_file_path}")
+    await write_text_file_async(json_modules_file_path, json_str)
+    return modules
+
+
+@typechecked
+async def _append_compose_env(
+    task: Task, modules: List[str], project_dir: str, app_name: str, module_name: str
+):
+    kebab_app_name = to_kebab_case(app_name)
+    snake_module_name = to_snake_case(module_name)
+    upper_snake_module_name = snake_module_name.upper()
+    compose_template_env_path = os.path.join(
+        project_dir, "src", kebab_app_name, "docker-compose.env"
+    )
+    compose_env_map = dotenv_values(compose_template_env_path)
+    host_port = int(compose_env_map.get("APP_GATEWAY_HOST_PORT", "8080"))
+    module_app_port = host_port + len(modules)
+    new_env_str = "\n".join(
+        [
+            f"APP_{upper_snake_module_name}_HOST_MODULE_PORT={module_app_port}",
+            f"APP_{upper_snake_module_name}_MODULE_PORT={module_app_port}",
+        ]
+    )
+    task.print_out(f"Add new environment to: {compose_template_env_path}")
+    await append_text_file_async(compose_template_env_path, new_env_str)

zrb/builtin/project/add/fastapp/module/_helper/register_migration.py

@@ -0,0 +1,35 @@
+import os
+
+from zrb.helper.codemod.add_import_module import add_import_module
+from zrb.helper.codemod.append_code_to_function import append_code_to_function
+from zrb.helper.file.text import read_text_file_async, write_text_file_async
+from zrb.helper.typecheck import typechecked
+from zrb.helper.util import to_kebab_case, to_snake_case
+from zrb.task.task import Task
+
+
+@typechecked
+async def register_migration(
+    task: Task, project_dir: str, app_name: str, module_name: str
+):
+    kebab_app_name = to_kebab_case(app_name)
+    snake_module_name = to_snake_case(module_name)
+    app_migration_file_path = os.path.join(
+        project_dir, "src", kebab_app_name, "src", "migrate.py"
+    )
+    import_module_path = ".".join(["module", snake_module_name, "migrate"])
+    function_name = f"migrate_{snake_module_name}"
+    task.print_out(f"Read code from: {app_migration_file_path}")
+    code = await read_text_file_async(app_migration_file_path)
+    task.print_out(
+        f'Add import "{function_name}" from "{import_module_path}" to the code'
+    )
+    code = add_import_module(
+        code=code, module_path=import_module_path, resource=function_name
+    )
+    task.print_out(f'Add "{function_name}" call to the code')
+    code = append_code_to_function(
+        code=code, function_name="migrate", new_code=f"await {function_name}()"
+    )
+    task.print_out(f"Write modified code to: {app_migration_file_path}")
+    await write_text_file_async(app_migration_file_path, code)

zrb/builtin/project/add/fastapp/module/_helper/register_module.py

@@ -0,0 +1,33 @@
+import os
+
+from zrb.helper.codemod.add_function_call import add_function_call
+from zrb.helper.codemod.add_import_module import add_import_module
+from zrb.helper.file.text import read_text_file_async, write_text_file_async
+from zrb.helper.typecheck import typechecked
+from zrb.helper.util import to_kebab_case, to_snake_case
+from zrb.task.task import Task
+
+
+@typechecked
+async def register_module(
+    task: Task, project_dir: str, app_name: str, module_name: str
+):
+    kebab_app_name = to_kebab_case(app_name)
+    snake_module_name = to_snake_case(module_name)
+    app_main_file_path = os.path.join(
+        project_dir, "src", kebab_app_name, "src", "main.py"
+    )
+    import_module_path = ".".join(["module", snake_module_name, "register_module"])
+    function_name = f"register_{snake_module_name}"
+    task.print_out(f"Read code from: {app_main_file_path}")
+    code = await read_text_file_async(app_main_file_path)
+    task.print_out(
+        f'Add import "{function_name}" from "{import_module_path}" to the code'
+    )
+    code = add_import_module(
+        code=code, module_path=import_module_path, resource=function_name
+    )
+    task.print_out(f'Add "{function_name}" call to the code')
+    code = add_function_call(code=code, function_name=function_name, parameters=[])
+    task.print_out(f"Write modified code to: {app_main_file_path}")
+    await write_text_file_async(app_main_file_path, code)

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

@@ -88,57 +88,28 @@ async def add_fastapp_module(*args: Any, **kwargs: Any):
     project_dir = kwargs.get("project_dir", ".")
     app_name = kwargs.get("app_name")
     module_name = kwargs.get("module_name")
-    kebab_app_name = util.to_kebab_case(app_name)
-    snake_app_name = util.to_snake_case(app_name)
-    kebab_module_name = util.to_kebab_case(module_name)
-    snake_module_name = util.to_snake_case(module_name)
-    upper_snake_module_name = snake_module_name.upper()
     await asyncio.gather(
         asyncio.create_task(
-            create_microservice_config(
-                task,
-                project_dir,
-                kebab_app_name,
-                snake_app_name,
-                kebab_module_name,
-                snake_module_name,
-                upper_snake_module_name,
-            )
-        ),
-        asyncio.create_task(
-            register_module(task, project_dir, kebab_app_name, snake_module_name)
+            create_microservice_config(task, project_dir, app_name, module_name)
         ),
+        asyncio.create_task(register_module(task, project_dir, app_name, module_name)),
         asyncio.create_task(
-            register_migration(task, project_dir, kebab_app_name, snake_module_name)
+            register_migration(task, project_dir, app_name, module_name)
         ),
         asyncio.create_task(
-            create_app_config(
-                task,
-                project_dir,
-                kebab_app_name,
-                snake_module_name,
-                upper_snake_module_name,
-            )
+            create_app_config(task, project_dir, app_name, module_name)
         ),
         asyncio.create_task(
-            append_all_enabled_env(
-                task, project_dir, kebab_app_name, upper_snake_module_name
-            )
+            append_all_enabled_env(task, project_dir, app_name, module_name)
         ),
         asyncio.create_task(
-            append_all_disabled_env(
-                task, project_dir, kebab_app_name, upper_snake_module_name
-            )
+            append_all_disabled_env(task, project_dir, app_name, module_name)
         ),
         asyncio.create_task(
-            append_src_template_env(
-                task, project_dir, kebab_app_name, upper_snake_module_name
-            )
+            append_src_template_env(task, project_dir, app_name, module_name)
         ),
         asyncio.create_task(
-            append_deployment_template_env(
-                task, project_dir, kebab_app_name, upper_snake_module_name
-            )
+            append_deployment_template_env(task, project_dir, app_name, module_name)
         ),
     )
     task.print_out(colored("Fastapp crud added", color="yellow"))

zrb/builtin/project/add/fastapp/module/template/src/kebab-zrb-app-name/src/module/snake_zrb_module_name/migrate.py

@@ -1,4 +1,4 @@
-from config import app_enable_snake_zrb_module_name_module
+from config import APP_ENABLE_SNAKE_ZRB_MODULE_NAME_MODULE
 from helper.migration import migrate
 from integration.db_connection import engine
 from integration.log import logger
@@ -6,7 +6,7 @@ from module.snake_zrb_module_name.integration import Base
 
 
 async def migrate_snake_zrb_module_name():
-    if not app_enable_snake_zrb_module_name_module:
+    if not APP_ENABLE_SNAKE_ZRB_MODULE_NAME_MODULE:
         logger.info('🥪 Skip DB migration for "snake_zrb_module_name"')
         return
     logger.info('🥪 Perform DB migration for "snake_zrb_module_name"')

zrb/builtin/project/add/fastapp/module/template/src/kebab-zrb-app-name/src/module/snake_zrb_module_name/register_module.py

@@ -1,8 +1,8 @@
 from config import (
-    app_enable_api,
-    app_enable_event_handler,
-    app_enable_rpc_server,
-    app_enable_snake_zrb_module_name_module,
+    APP_ENABLE_API,
+    APP_ENABLE_EVENT_HANDLER,
+    APP_ENABLE_RPC_SERVER,
+    APP_ENABLE_SNAKE_ZRB_MODULE_NAME_MODULE,
 )
 from integration.app.app import app
 from integration.log import logger
@@ -15,10 +15,10 @@ from module.snake_zrb_module_name.rpc import register_rpc
 
 
 def register_snake_zrb_module_name():
-    if not app_enable_snake_zrb_module_name_module:
+    if not APP_ENABLE_SNAKE_ZRB_MODULE_NAME_MODULE:
         logger.info('🥪 Skip registering "snake_zrb_module_name"')
         return
-    if app_enable_api:
+    if APP_ENABLE_API:
         register_api(
             logger=logger,
             app=app,
@@ -26,11 +26,11 @@ def register_snake_zrb_module_name():
             rpc_caller=rpc_caller,
             publisher=publisher,
         )
-    if app_enable_event_handler:
+    if APP_ENABLE_EVENT_HANDLER:
         register_event(
             logger=logger, consumer=consumer, rpc_caller=rpc_caller, publisher=publisher
         )
-    if app_enable_rpc_server:
+    if APP_ENABLE_RPC_SERVER:
         register_rpc(
             logger=logger,
             rpc_server=rpc_server,

zrb/builtin/project/add/plugin/plugin.py

@@ -17,7 +17,7 @@ from zrb.builtin.project.add.plugin._input import (
     package_repository_input,
 )
 from zrb.builtin.project.add.project_task import add_project_tasks
-from zrb.config.config import version
+from zrb.config.config import VERSION
 from zrb.helper.accessories.color import colored
 from zrb.helper.typing import Any
 from zrb.runner import runner
@@ -61,7 +61,7 @@ copy_resource = ResourceMaker(
         "zrbPackageDocumentation": "{{input.package_documentation}}",
         "zrbPackageAuthorName": "{{input.package_author_name}}",
         "zrbPackageAuthorEmail": "{{input.package_author_email}}",
-        "zrbVersion": version,
+        "zrbVersion": VERSION,
     },
     template_path=os.path.join(_CURRENT_DIR, "template"),
     destination_path="{{ input.project_dir }}",

zrb/builtin/project/create/create.py

@@ -10,7 +10,7 @@ from zrb.builtin.project.create._input import (
     project_description_input,
     project_name_input,
 )
-from zrb.config.config import version
+from zrb.config.config import VERSION
 from zrb.helper.accessories.color import colored
 from zrb.helper.typing import Any
 from zrb.runner import runner
@@ -57,7 +57,7 @@ copy_resource = ResourceMaker(
         "zrbProjectAuthorName": "{{input.project_author_name}}",
         "zrbProjectAuthorEmail": "{{input.project_author_email}}",
         "zrbImageDefaultNamespace": _IMAGE_DEFAULT_NAMESPACE,
-        "zrbVersion": version,
+        "zrbVersion": VERSION,
     },
     replacement_mutator=copy_resource_replacement_mutator,
     template_path=os.path.join(_CURRENT_DIR, "template"),

zrb/builtin/version.py

@@ -1,4 +1,4 @@
-from zrb.config.config import version
+from zrb.config.config import VERSION
 from zrb.helper.typing import Any
 from zrb.runner import runner
 from zrb.task.decorator import python_task
@@ -8,5 +8,5 @@ from zrb.task.task import Task
 @python_task(name="version", description="Get Zrb version", runner=runner)
 async def get_version(*args: Any, **kwargs: Any) -> str:
     task: Task = kwargs.get("_task")
-    task.print_out(version)
-    return version
+    task.print_out(VERSION)
+    return VERSION

zrb/config/config.py

@@ -30,19 +30,19 @@ def _get_default_tmp_dir() -> str:
     return os.path.expanduser(os.path.join("~", ".tmp"))
 
 
-tmp_dir = os.getenv("ZRB_TMP_DIR", _get_default_tmp_dir())
-default_shell = os.getenv("ZRB_SHELL", _get_current_shell())
-default_editor = os.getenv("ZRB_EDITOR", "nano")
-init_script_str = os.getenv("ZRB_INIT_SCRIPTS", "")
-init_scripts = init_script_str.split(":") if init_script_str != "" else []
-logging_level = untyped_to_logging_level(os.getenv("ZRB_LOGGING_LEVEL", "WARNING"))
-should_load_builtin = untyped_to_boolean(os.getenv("ZRB_SHOULD_LOAD_BUILTIN", "1"))
-env_prefix = os.getenv("ZRB_ENV", "")
-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(
+TMP_DIR = os.getenv("ZRB_TMP_DIR", _get_default_tmp_dir())
+DEFAULT_SHELL = os.getenv("ZRB_SHELL", _get_current_shell())
+DEFAULT_EDITOR = os.getenv("ZRB_EDITOR", "nano")
+INIT_SCRIPT_STR = os.getenv("ZRB_INIT_SCRIPTS", "")
+INIT_SCRIPTS = INIT_SCRIPT_STR.split(":") if INIT_SCRIPT_STR != "" else []
+LOGGING_LEVEL = untyped_to_logging_level(os.getenv("ZRB_LOGGING_LEVEL", "WARNING"))
+SHOULD_LOAD_BUILTIN = untyped_to_boolean(os.getenv("ZRB_SHOULD_LOAD_BUILTIN", "1"))
+ENV_PREFIX = os.getenv("ZRB_ENV", "")
+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"))
+ENABLE_TYPE_CHECKING = untyped_to_boolean(os.getenv("ZRB_ENABLE_TYPE_CHECKING", "1"))

zrb/helper/callable.py

@@ -1,13 +1,15 @@
 import asyncio
 import inspect
-from typing import Any, Callable
+from typing import Any, Callable, Coroutine
 
 from zrb.helper.accessories.color import colored
 from zrb.helper.log import logger
+from zrb.helper.typecheck import typechecked
 
 logger.debug(colored("Loading zrb.helper.callable", attrs=["dark"]))
 
 
+@typechecked
 async def run_async(fn: Callable, *args: Any, **kwargs: Any) -> Any:
     if inspect.iscoroutinefunction(fn):
         return await fn(*args, **kwargs)

zrb/helper/cli.py

@@ -4,7 +4,7 @@ from functools import lru_cache
 
 import click
 
-from zrb.config.config import init_scripts, should_load_builtin, version
+from zrb.config.config import INIT_SCRIPTS, SHOULD_LOAD_BUILTIN, VERSION
 from zrb.helper.accessories.color import colored
 from zrb.helper.loader.load_module import load_module
 from zrb.helper.log import logger
@@ -18,7 +18,7 @@ HELP = f"""
    zzzzz rr rr  bb
      zz  rrr  r bbbbbb
     zz   rr     bb   bb
-   zzzzz rr     bbbbbb   {version}
+   zzzzz rr     bbbbbb   {VERSION}
    _ _ . .  . _ .  _ . . .
 
 Super framework for your super app.
@@ -40,7 +40,7 @@ def create_cli() -> click.Group:
     logger.info(colored("Prepare CLI", attrs=["dark"]))
     zrb_cli_group = MultilineHelpClickGroup(name="zrb", help=HELP)
     # Load default tasks
-    if should_load_builtin:
+    if SHOULD_LOAD_BUILTIN:
         logger.info(colored("Load builtins", attrs=["dark"]))
         from zrb import builtin
 
@@ -50,7 +50,7 @@ def create_cli() -> click.Group:
     project_script = os.path.join(project_dir, "zrb_init.py")
     load_module(script_path=project_script, sys_path_index=0)
     # load from ZRB_INIT_SCRIPTS environment
-    for index, init_script in enumerate(init_scripts):
+    for index, init_script in enumerate(INIT_SCRIPTS):
         logger.info(colored(f"Load module from {init_script}", attrs=["dark"]))
         try:
             load_module(script_path=init_script, sys_path_index=index + 1)

zrb/helper/log.py

@@ -1,15 +1,15 @@
 import logging
 
-from zrb.config.config import logging_level
+from zrb.config.config import LOGGING_LEVEL
 from zrb.helper.accessories.untyped_color import untyped_colored as colored
 
 # create logger
 logger = logging.getLogger("zrb")
-logger.setLevel(logging_level)
+logger.setLevel(LOGGING_LEVEL)
 
 # create console handler and set level to debug
 ch = logging.StreamHandler()
-ch.setLevel(logging_level)
+ch.setLevel(LOGGING_LEVEL)
 
 # create formatter
 formatter = logging.Formatter(

zrb/helper/typecheck.py

@@ -1,6 +1,6 @@
 from typing import TypeVar
 
-from zrb.config.config import enable_type_checking
+from zrb.config.config import ENABLE_TYPE_CHECKING
 from zrb.helper.accessories.untyped_color import untyped_colored as colored
 from zrb.helper.log import logger
 
@@ -9,7 +9,7 @@ T = TypeVar("T")
 
 
 def typechecked(anything: T) -> T:
-    if enable_type_checking:
+    if ENABLE_TYPE_CHECKING:
         from beartype import beartype
 
         return beartype(anything)

zrb/helper/typing.py

@@ -1,10 +1,10 @@
-from zrb.config.config import enable_type_checking
+from zrb.config.config import ENABLE_TYPE_CHECKING
 from zrb.helper.accessories.untyped_color import untyped_colored as colored
 from zrb.helper.log import logger
 
 logger.debug(colored("Loading zrb.helper.typing", attrs=["dark"]))
 
-if enable_type_checking:
+if ENABLE_TYPE_CHECKING:
     from beartype.typing import (
         Any,
         Callable,

zrb/helper/util.py

@@ -1,4 +1,5 @@
 import re
+from functools import lru_cache
 
 import jinja2
 
@@ -18,6 +19,7 @@ def _is_undefined(value: Any) -> bool:
     return value is None or isinstance(value, jinja2.Undefined)
 
 
+@lru_cache
 @typechecked
 def coalesce(value: Any, *alternatives: Any) -> Any:
     if not _is_undefined(value):
@@ -28,6 +30,7 @@ def coalesce(value: Any, *alternatives: Any) -> Any:
     return None
 
 
+@lru_cache
 @typechecked
 def coalesce_str(value: Any, *alternatives: Any) -> Any:
     if not _is_undefined(value) and value != "":
@@ -38,6 +41,7 @@ def coalesce_str(value: Any, *alternatives: Any) -> Any:
     return ""
 
 
+@lru_cache
 @typechecked
 def to_camel_case(text: Optional[str]) -> str:
     text = str(text) if not _is_undefined(text) else ""
@@ -47,6 +51,7 @@ def to_camel_case(text: Optional[str]) -> str:
     return pascal[0].lower() + pascal[1:]
 
 
+@lru_cache
 @typechecked
 def to_pascal_case(text: Optional[str]) -> str:
     text = str(text) if not _is_undefined(text) else ""
@@ -56,6 +61,7 @@ def to_pascal_case(text: Optional[str]) -> str:
     )
 
 
+@lru_cache
 @typechecked
 def to_kebab_case(text: Optional[str]) -> str:
     text = str(text) if not _is_undefined(text) else ""
@@ -63,6 +69,7 @@ def to_kebab_case(text: Optional[str]) -> str:
     return "-".join([x.lower() for x in _to_space_separated(text).split(" ")])
 
 
+@lru_cache
 @typechecked
 def to_snake_case(text: Optional[str]) -> str:
     text = str(text) if not _is_undefined(text) else ""
@@ -70,12 +77,14 @@ def to_snake_case(text: Optional[str]) -> str:
     return "_".join([x.lower() for x in _to_space_separated(text).split(" ")])
 
 
+@lru_cache
 @typechecked
 def _to_alphanum(text: Optional[str]) -> str:
     text = str(text) if not _is_undefined(text) else ""
     return NON_ALPHA_NUM.sub(" ", text)
 
 
+@lru_cache
 @typechecked
 def to_human_readable(text: Optional[str]) -> str:
     text = str(text) if not _is_undefined(text) else ""
@@ -87,11 +96,13 @@ def to_human_readable(text: Optional[str]) -> str:
     )
 
 
+@lru_cache
 @typechecked
 def to_capitalized_human_readable(text: Optional[str]) -> str:
     return to_human_readable(text).capitalize()
 
 
+@lru_cache
 @typechecked
 def _to_space_separated(text: Optional[str]) -> str:
     text = str(text) if not _is_undefined(text) else ""
@@ -122,6 +133,7 @@ def _to_space_separated(text: Optional[str]) -> str:
     return " ".join(new_parts).strip(" ")
 
 
+@lru_cache
 @typechecked
 def to_boolean(text: str) -> bool:
     return conversion_to_boolean(text)

zrb/runner.py

@@ -1,7 +1,7 @@
 from zrb.action.runner import Runner
-from zrb.config.config import env_prefix
+from zrb.config.config import ENV_PREFIX
 from zrb.helper.accessories.color import colored
 from zrb.helper.log import logger
 
 logger.debug(colored("Loading zrb.runner", attrs=["dark"]))
-runner = Runner(env_prefix=env_prefix)
+runner = Runner(env_prefix=ENV_PREFIX)

zrb/task/base_task/base_task.py

@@ -4,7 +4,7 @@ import os
 import shutil
 
 from zrb.advertisement import advertisements
-from zrb.config.config import show_advertisement, tmp_dir
+from zrb.config.config import SHOW_ADVERTISEMENT, TMP_DIR
 from zrb.helper.accessories.name import get_random_name
 from zrb.helper.advertisement import get_advertisement
 from zrb.helper.callable import run_async
@@ -127,7 +127,7 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
     def __get_xcom_dir(self, execution_id: Optional[str] = None) -> str:
         if execution_id is None:
             execution_id = self.get_execution_id()
-        return os.path.join(tmp_dir, f"xcom.{execution_id}")
+        return os.path.join(TMP_DIR, f"xcom.{execution_id}")
 
     def __ensure_xcom_dir_exists(self, execution_id: Optional[str] = None):
         xcom_dir = self.__get_xcom_dir(execution_id=execution_id)
@@ -303,7 +303,7 @@ class BaseTask(FinishTracker, AttemptTracker, Renderer, BaseTaskModel, AnyTask):
             await asyncio.sleep(self._checking_interval)
         self._end_timer()
         if show_done_info:
-            if show_advertisement:
+            if SHOW_ADVERTISEMENT:
                 selected_advertisement = get_advertisement(advertisements)
                 selected_advertisement.show()
             self._show_done_info()