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

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

@@ -0,0 +1,47 @@
+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_capitalized_human_readable, to_kebab_case, to_snake_case
+from zrb.task.task import Task
+
+from ._common import get_app_frontend_routes_dir, replace_marker
+
+
+@typechecked
+async def inject_list_page(
+    task: Task,
+    project_dir: str,
+    app_name: str,
+    module_name: str,
+    entity_name: str,
+    column_name: str,
+):
+    kebab_module_name = to_kebab_case(module_name)
+    kebab_entity_name = to_kebab_case(entity_name)
+    snake_column_name = to_snake_case(column_name)
+    column_caption = to_capitalized_human_readable(column_name)
+    file_path = os.path.join(
+        get_app_frontend_routes_dir(project_dir, app_name),
+        kebab_module_name,
+        kebab_entity_name,
+        "+page.svelte",
+    )
+    task.print_out(f"Read HTML from: {file_path}")
+    html_content = await read_text_file_async(file_path)
+    # process header
+    task.print_out("Add column header to table")
+    html_content = replace_marker(
+        html_content,
+        marker="<!-- DON'T DELETE: insert new column header here-->",
+        code=f"<th>{column_caption}</th>",
+    )
+    # process column
+    task.print_out("Add column to table")
+    html_content = replace_marker(
+        html_content,
+        marker="<!-- DON'T DELETE: insert new column here-->",
+        code=f"<td>{{row.{snake_column_name}}}</td>",
+    )
+    task.print_out(f"Write modified HTML to: {file_path}")
+    await write_text_file_async(file_path, html_content)

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

@@ -0,0 +1,47 @@
+import os
+
+from zrb.helper.codemod.add_property_to_class import add_property_to_class
+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_pascal_case, to_snake_case
+from zrb.task.task import Task
+
+from ._common import get_app_dir, get_sqlalchemy_column_type
+
+
+@typechecked
+async def inject_repo(
+    task: Task,
+    project_dir: str,
+    app_name: str,
+    module_name: str,
+    entity_name: str,
+    column_name: str,
+    column_type: str,
+):
+    snake_module_name = to_snake_case(module_name)
+    snake_entity_name = to_snake_case(entity_name)
+    pascal_entity_name = to_pascal_case(entity_name)
+    snake_column_name = to_snake_case(column_name)
+    repo_file_path = os.path.join(
+        get_app_dir(project_dir, app_name),
+        "src",
+        "module",
+        snake_module_name,
+        "entity",
+        snake_entity_name,
+        "repo.py",
+    )
+    task.print_out(f"Read code from: {repo_file_path}")
+    code = await read_text_file_async(repo_file_path)
+    task.print_out(f'Add column "{snake_column_name}" to the repo')
+    sqlalchemy_column_type = get_sqlalchemy_column_type(column_type)
+    code = add_property_to_class(
+        code=code,
+        class_name=f"DBEntity{pascal_entity_name}",
+        property_name=snake_column_name,
+        property_type="Column",
+        property_value=f"Column({sqlalchemy_column_type})",
+    )
+    task.print_out(f"Write modified code to: {repo_file_path}")
+    await write_text_file_async(repo_file_path, code)

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

@@ -0,0 +1,45 @@
+import os
+
+from zrb.helper.codemod.add_property_to_class import add_property_to_class
+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_pascal_case, to_snake_case
+from zrb.task.task import Task
+
+from ._common import get_app_dir, get_python_column_type
+
+
+@typechecked
+async def inject_schema(
+    task: Task,
+    project_dir: str,
+    app_name: str,
+    module_name: str,
+    entity_name: str,
+    column_name: str,
+    column_type: str,
+):
+    snake_module_name = to_snake_case(module_name)
+    snake_entity_name = to_snake_case(entity_name)
+    pascal_entity_name = to_pascal_case(entity_name)
+    snake_column_name = to_snake_case(column_name)
+    schema_file_path = os.path.join(
+        get_app_dir(project_dir, app_name),
+        "src",
+        "module",
+        snake_module_name,
+        "schema",
+        f"{snake_entity_name}.py",
+    )
+    task.print_out(f"Read code from: {schema_file_path}")
+    code = await read_text_file_async(schema_file_path)
+    task.print_out(f'Add column "{snake_column_name}" to the schema')
+    python_column_type = get_python_column_type(column_type)
+    code = add_property_to_class(
+        code=code,
+        class_name=f"{pascal_entity_name}Data",
+        property_name=snake_column_name,
+        property_type=f"Optional[{python_column_type}]",
+    )
+    task.print_out(f"Write modified code to: {schema_file_path}")
+    await write_text_file_async(schema_file_path, code)

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

@@ -0,0 +1,49 @@
+import os
+
+from zrb.helper.codemod.add_key_value_to_dict import add_key_value_to_dict
+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_snake_case
+from zrb.task.task import Task
+
+from ._common import get_app_dir, get_python_value_for_testing
+
+
+@typechecked
+async def inject_test(
+    task: Task,
+    project_dir: str,
+    app_name: str,
+    module_name: str,
+    entity_name: str,
+    column_name: str,
+    column_type: str,
+):
+    snake_module_name = to_snake_case(module_name)
+    snake_entity_name = to_snake_case(entity_name)
+    snake_column_name = to_snake_case(column_name)
+    test_file_path = os.path.join(
+        get_app_dir(project_dir, app_name),
+        "test",
+        snake_module_name,
+        f"test_{snake_entity_name}.py",
+    )
+    task.print_out(f"Read code from: {test_file_path}")
+    code = await read_text_file_async(test_file_path)
+    task.print_out(f'Add column "{snake_column_name}" to the test')
+    dict_names = [
+        "inserted_success_data",
+        "to_be_updated_success_data",
+        "updated_success_data",
+        "to_be_deleted_success_data",
+    ]
+    default_python_value = get_python_value_for_testing(column_type)
+    for dict_name in dict_names:
+        code = add_key_value_to_dict(
+            code=code,
+            dict_name=dict_name,
+            key=f"'{snake_column_name}'",
+            value=default_python_value,
+        )
+    task.print_out(f"Write modified code to: {test_file_path}")
+    await write_text_file_async(test_file_path, code)

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

@@ -0,0 +1,50 @@
+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_capitalized_human_readable, to_kebab_case
+from zrb.task.task import Task
+
+from ._common import get_app_frontend_routes_dir, get_html_input, replace_marker
+
+
+@typechecked
+async def inject_update_page(
+    task: Task,
+    project_dir: str,
+    app_name: str,
+    module_name: str,
+    entity_name: str,
+    column_name: str,
+    column_type: str,
+):
+    kebab_module_name = to_kebab_case(module_name)
+    kebab_entity_name = to_kebab_case(entity_name)
+    kebab_column_name = to_kebab_case(column_name)
+    column_caption = to_capitalized_human_readable(column_name)
+    list_page_file_path = os.path.join(
+        get_app_frontend_routes_dir(project_dir, app_name),
+        kebab_module_name,
+        kebab_entity_name,
+        "update",
+        "[id]",
+        "+page.svelte",
+    )
+    task.print_out(f"Read HTML from: {list_page_file_path}")
+    html_content = await read_text_file_async(list_page_file_path)
+    task.print_out("Add field to update page")
+    html_input = get_html_input(column_type, column_name, column_caption)
+    html_content = replace_marker(
+        html_content,
+        marker="<!-- DON'T DELETE: insert new field here-->",
+        code="\n".join(
+            [
+                '<div class="mb-4">',
+                f'    <label class="block text-gray-700 font-bold mb-2" for="{kebab_column_name}">{column_caption}</label>',  # noqa
+                f"    {html_input}",
+                "</div>",
+            ]
+        ),
+    )
+    task.print_out(f"Write modified HTML to: {list_page_file_path}")
+    await write_text_file_async(list_page_file_path, html_content)

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

@@ -1,3 +1,4 @@
+from zrb.task_input.choice_input import ChoiceInput
 from zrb.task_input.str_input import StrInput
 
 column_name_input = StrInput(
@@ -8,10 +9,21 @@ column_name_input = StrInput(
     default="title",
 )
 
-column_type_input = StrInput(
+column_type_input = ChoiceInput(
     name="column-type",
     shortcut="t",
     description="Column type",
     prompt="Column type",
-    default="str",
+    choices=[
+        "string",
+        "text",
+        "boolean",
+        "integer",
+        "float",
+        "double",
+        "date",
+        "datetime",
+        "time",
+    ],
+    default="string",
 )

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,109 +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)
-    column_caption = util.to_capitalized_human_readable(column_name)
+    column_type = kwargs.get("column_type")
     await asyncio.gather(
         asyncio.create_task(
-            add_column_to_test(
+            inject_test(
                 task=task,
                 project_dir=project_dir,
-                kebab_app_name=kebab_app_name,
-                snake_module_name=snake_module_name,
-                snake_entity_name=snake_entity_name,
-                snake_column_name=snake_column_name,
+                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(
+            inject_schema(
                 task=task,
                 project_dir=project_dir,
-                kebab_app_name=kebab_app_name,
-                snake_module_name=snake_module_name,
-                snake_entity_name=snake_entity_name,
-                pascal_entity_name=pascal_entity_name,
-                snake_column_name=snake_column_name,
+                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(
+            inject_repo(
                 task=task,
                 project_dir=project_dir,
-                kebab_app_name=kebab_app_name,
-                snake_module_name=snake_module_name,
-                snake_entity_name=snake_entity_name,
-                pascal_entity_name=pascal_entity_name,
-                snake_column_name=snake_column_name,
+                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(
+            inject_list_page(
                 task=task,
                 project_dir=project_dir,
-                kebab_app_name=kebab_app_name,
-                kebab_module_name=kebab_module_name,
-                kebab_entity_name=kebab_entity_name,
-                snake_column_name=snake_column_name,
-                column_caption=column_caption,
+                app_name=app_name,
+                module_name=module_name,
+                entity_name=entity_name,
+                column_name=column_name,
             )
         ),
         asyncio.create_task(
-            add_column_to_detail_page(
+            inject_detail_page(
                 task=task,
                 project_dir=project_dir,
-                kebab_app_name=kebab_app_name,
-                kebab_module_name=kebab_module_name,
-                kebab_entity_name=kebab_entity_name,
-                kebab_column_name=kebab_column_name,
-                snake_column_name=snake_column_name,
-                column_caption=column_caption,
+                app_name=app_name,
+                module_name=module_name,
+                entity_name=entity_name,
+                column_name=column_name,
             )
         ),
         asyncio.create_task(
-            add_column_to_delete_page(
+            inject_delete_page(
                 task=task,
                 project_dir=project_dir,
-                kebab_app_name=kebab_app_name,
-                kebab_module_name=kebab_module_name,
-                kebab_entity_name=kebab_entity_name,
-                kebab_column_name=kebab_column_name,
-                snake_column_name=snake_column_name,
-                column_caption=column_caption,
+                app_name=app_name,
+                module_name=module_name,
+                entity_name=entity_name,
+                column_name=column_name,
             )
         ),
         asyncio.create_task(
-            add_column_to_update_page(
+            inject_update_page(
                 task=task,
                 project_dir=project_dir,
-                kebab_app_name=kebab_app_name,
-                kebab_module_name=kebab_module_name,
-                kebab_entity_name=kebab_entity_name,
-                kebab_column_name=kebab_column_name,
-                snake_column_name=snake_column_name,
-                column_caption=column_caption,
+                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(
+            inject_insert_page(
                 task=task,
                 project_dir=project_dir,
-                kebab_app_name=kebab_app_name,
-                kebab_module_name=kebab_module_name,
-                kebab_entity_name=kebab_entity_name,
-                kebab_column_name=kebab_column_name,
-                snake_column_name=snake_column_name,
-                column_caption=column_caption,
+                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)