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

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

@@ -7,14 +7,14 @@ from zrb.builtin.project.add.fastapp._group import project_add_fastapp_group
 from zrb.builtin.project.add.fastapp.app._input import app_name_input
 from zrb.builtin.project.add.fastapp.crud._input import entity_name_input
 from zrb.builtin.project.add.fastapp.field._helper import (
-    add_column_to_delete_page,
-    add_column_to_detail_page,
-    add_column_to_insert_page,
-    add_column_to_list_page,
-    add_column_to_repo,
-    add_column_to_schema,
-    add_column_to_test,
-    add_column_to_update_page,
+    inject_delete_page,
+    inject_detail_page,
+    inject_insert_page,
+    inject_list_page,
+    inject_repo,
+    inject_schema,
+    inject_test,
+    inject_update_page,
 )
 from zrb.builtin.project.add.fastapp.field._input import (
     column_name_input,
@@ -80,111 +80,91 @@ async def add_fastapp_field(*args: Any, **kwargs: Any):
     module_name = kwargs.get("module_name")
     entity_name = kwargs.get("entity_name")
     column_name = kwargs.get("column_name")
-    column_type = kwargs.get("column_name")
-    kebab_app_name = util.to_kebab_case(app_name)
-    kebab_module_name = util.to_kebab_case(module_name)
-    snake_module_name = util.to_snake_case(module_name)
-    kebab_entity_name = util.to_kebab_case(entity_name)
-    snake_entity_name = util.to_snake_case(entity_name)
-    pascal_entity_name = util.to_pascal_case(entity_name)
-    snake_column_name = util.to_snake_case(column_name)
-    kebab_column_name = util.to_kebab_case(column_name)
-    capitalized_human_readable_column_name = util.to_capitalized_human_readable(  # noqa
-        column_name
-    )
+    column_type = kwargs.get("column_type")
     await asyncio.gather(
         asyncio.create_task(
-            add_column_to_test(
-                task,
-                project_dir,
-                kebab_app_name,
-                snake_module_name,
-                snake_entity_name,
-                snake_column_name,
-                column_type,
+            inject_test(
+                task=task,
+                project_dir=project_dir,
+                app_name=app_name,
+                module_name=module_name,
+                entity_name=entity_name,
+                column_name=column_name,
+                column_type=column_type,
             )
         ),
         asyncio.create_task(
-            add_column_to_schema(
-                task,
-                project_dir,
-                kebab_app_name,
-                snake_module_name,
-                snake_entity_name,
-                pascal_entity_name,
-                snake_column_name,
-                column_type,
+            inject_schema(
+                task=task,
+                project_dir=project_dir,
+                app_name=app_name,
+                module_name=module_name,
+                entity_name=entity_name,
+                column_name=column_name,
+                column_type=column_type,
             )
         ),
         asyncio.create_task(
-            add_column_to_repo(
-                task,
-                project_dir,
-                kebab_app_name,
-                snake_module_name,
-                snake_entity_name,
-                pascal_entity_name,
-                snake_column_name,
-                column_type,
+            inject_repo(
+                task=task,
+                project_dir=project_dir,
+                app_name=app_name,
+                module_name=module_name,
+                entity_name=entity_name,
+                column_name=column_name,
+                column_type=column_type,
             )
         ),
         asyncio.create_task(
-            add_column_to_list_page(
-                task,
-                project_dir,
-                kebab_app_name,
-                kebab_module_name,
-                kebab_entity_name,
-                snake_column_name,
-                capitalized_human_readable_column_name,
+            inject_list_page(
+                task=task,
+                project_dir=project_dir,
+                app_name=app_name,
+                module_name=module_name,
+                entity_name=entity_name,
+                column_name=column_name,
             )
         ),
         asyncio.create_task(
-            add_column_to_detail_page(
-                task,
-                project_dir,
-                kebab_app_name,
-                kebab_module_name,
-                kebab_entity_name,
-                kebab_column_name,
-                snake_column_name,
-                capitalized_human_readable_column_name,
+            inject_detail_page(
+                task=task,
+                project_dir=project_dir,
+                app_name=app_name,
+                module_name=module_name,
+                entity_name=entity_name,
+                column_name=column_name,
             )
         ),
         asyncio.create_task(
-            add_column_to_delete_page(
-                task,
-                project_dir,
-                kebab_app_name,
-                kebab_module_name,
-                kebab_entity_name,
-                kebab_column_name,
-                snake_column_name,
-                capitalized_human_readable_column_name,
+            inject_delete_page(
+                task=task,
+                project_dir=project_dir,
+                app_name=app_name,
+                module_name=module_name,
+                entity_name=entity_name,
+                column_name=column_name,
             )
         ),
         asyncio.create_task(
-            add_column_to_update_page(
-                task,
-                project_dir,
-                kebab_app_name,
-                kebab_module_name,
-                kebab_entity_name,
-                kebab_column_name,
-                snake_column_name,
-                capitalized_human_readable_column_name,
+            inject_update_page(
+                task=task,
+                project_dir=project_dir,
+                app_name=app_name,
+                module_name=module_name,
+                entity_name=entity_name,
+                column_name=column_name,
+                column_type=column_type,
             )
         ),
         asyncio.create_task(
-            add_column_to_insert_page(
-                task,
-                project_dir,
-                kebab_app_name,
-                kebab_module_name,
-                kebab_entity_name,
-                kebab_column_name,
-                snake_column_name,
-                capitalized_human_readable_column_name,
+            inject_insert_page(
+                task=task,
+                project_dir=project_dir,
+                app_name=app_name,
+                module_name=module_name,
+                entity_name=entity_name,
+                column_name=column_name,
+                column_type=column_type,
             )
         ),
     )

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

@@ -0,0 +1,17 @@
+from .append_all_disabled_env import append_all_disabled_env
+from .append_all_enabled_env import append_all_enabled_env
+from .append_deployment_template_env import append_deployment_template_env
+from .append_src_template_env import append_src_template_env
+from .create_app_config import create_app_config
+from .create_microservice_config import create_microservice_config
+from .register_migration import register_migration
+from .register_module import register_module
+
+assert append_all_disabled_env
+assert append_all_enabled_env
+assert append_deployment_template_env
+assert append_src_template_env
+assert create_app_config
+assert create_microservice_config
+assert register_migration
+assert register_module

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

@@ -0,0 +1,22 @@
+import os
+
+from zrb.helper.file.text import append_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 append_all_disabled_env(
+    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)
+    upper_snake_module_name = snake_module_name.upper()
+    all_disabled_env_path = os.path.join(
+        project_dir, "src", kebab_app_name, "all-module-disabled.env"
+    )
+    task.print_out(f"Add new environment to: {all_disabled_env_path}")
+    await append_text_file_async(
+        all_disabled_env_path, f"APP_ENABLE_{upper_snake_module_name}_MODULE=false"
+    )

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

@@ -0,0 +1,22 @@
+import os
+
+from zrb.helper.file.text import append_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 append_all_enabled_env(
+    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)
+    upper_snake_module_name = snake_module_name.upper()
+    all_enabled_env_path = os.path.join(
+        project_dir, "src", kebab_app_name, "all-module-enabled.env"
+    )
+    task.print_out(f"Add new environment to: {all_enabled_env_path}")
+    await append_text_file_async(
+        all_enabled_env_path, f"APP_ENABLE_{upper_snake_module_name}_MODULE=true"
+    )

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

@@ -0,0 +1,25 @@
+import os
+
+from zrb.helper.file.text import append_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 append_deployment_template_env(
+    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)
+    upper_snake_module_name = snake_module_name.upper()
+    deployment_template_env_path = os.path.join(
+        project_dir, "src", kebab_app_name, "deployment", "template.env"
+    )
+    new_env_str = "\n".join(
+        [
+            f"REPLICA_{upper_snake_module_name}_SERVICE=1",
+        ]
+    )
+    task.print_out(f"Add new environment to: {deployment_template_env_path}")
+    await append_text_file_async(deployment_template_env_path, new_env_str)

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

@@ -0,0 +1,25 @@
+import os
+
+from zrb.helper.file.text import append_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 append_src_template_env(
+    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)
+    upper_snake_module_name = snake_module_name.upper()
+    src_template_env_path = os.path.join(
+        project_dir, "src", kebab_app_name, "src", "template.env"
+    )
+    new_env_str = "\n".join(
+        [
+            f"APP_ENABLE_{upper_snake_module_name}_MODULE=true",
+        ]
+    )
+    task.print_out(f"Add new environment to: {src_template_env_path}")
+    await append_text_file_async(src_template_env_path, new_env_str)

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

@@ -0,0 +1,29 @@
+import os
+
+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 create_app_config(
+    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)
+    upper_snake_module_name = snake_module_name.upper()
+    config_file_path = os.path.join(
+        project_dir, "src", kebab_app_name, "src", "config.py"
+    )
+    config_code = "\n".join(
+        [
+            f"APP_ENABLE_{upper_snake_module_name}_MODULE = str_to_boolean(os.environ.get(",  # noqa
+            f"    'APP_ENABLE_{upper_snake_module_name}_MODULE', 'true'" "))",
+        ]
+    )
+    task.print_out(f"Read config from: {config_file_path}")
+    code = await read_text_file_async(config_file_path)
+    code += "\n" + config_code
+    task.print_out(f"Write config to: {config_file_path}")
+    await write_text_file_async(config_file_path, code)

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"')