zrb 0.6.0__py3-none-any.whl → 0.6.1__py3-none-any.whl

zrb/builtin/generator/fastapp_field/helper.py

@@ -1,11 +1,12 @@
-from zrb.helper.typecheck import typechecked
-from zrb.task.task import Task
-from zrb.helper.codemod.add_property_to_class import add_property_to_class
-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
 import os
 import re
 
+from zrb.helper.codemod.add_key_value_to_dict import add_key_value_to_dict
+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.task.task import Task
+
 
 @typechecked
 async def add_column_to_insert_page(
@@ -16,36 +17,45 @@ async def add_column_to_insert_page(
     kebab_entity_name: str,
     kebab_column_name: str,
     snake_column_name: str,
-    capitalized_human_readable_column_name: str
+    capitalized_human_readable_column_name: str,
 ):
     list_page_file_path = os.path.join(
-        project_dir, 'src', kebab_app_name, 'src', 'frontend', 'src', 'routes',
-        kebab_module_name, kebab_entity_name, 'new', '+page.svelte'
+        project_dir,
+        "src",
+        kebab_app_name,
+        "src",
+        "frontend",
+        "src",
+        "routes",
+        kebab_module_name,
+        kebab_entity_name,
+        "new",
+        "+page.svelte",
     )
-    task.print_out(f'Read HTML from: {list_page_file_path}')
+    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 default value to insert page')
+    task.print_out("Add default value to insert page")
     default_value_regex = r"(.*)(// DON'T DELETE: set field default value here)"  # noqa
-    default_value_subst = '\\n'.join([
-        f"\\1row.{snake_column_name} = '';",
-        '\\1\\2'
-    ])
+    default_value_subst = "\\n".join([f"\\1row.{snake_column_name} = '';", "\\1\\2"])
     html_content = re.sub(
         default_value_regex, default_value_subst, html_content, 0, re.MULTILINE
     )
-    task.print_out('Add field to insert page')
+    task.print_out("Add field to insert page")
     field_regex = r"(.*)(<!-- DON'T DELETE: insert new field here-->)"
-    field_subst = '\\n'.join([
-        '\\1<div class="mb-4">',
-        f'\\1    <label class="block text-gray-700 font-bold mb-2" for="{kebab_column_name}">{capitalized_human_readable_column_name}</label>', # noqa
-        f'\\1    <input type="text" class="input w-full" id="{kebab_column_name}" placeholder="{capitalized_human_readable_column_name}" bind:value=' + '{row.' + snake_column_name + '} />', # noqa
-        '\\1</div>',
-        '\\1\\2'
-    ])
-    html_content = re.sub(
-        field_regex, field_subst, html_content, 0, re.MULTILINE
+    field_subst = "\\n".join(
+        [
+            '\\1<div class="mb-4">',
+            f'\\1    <label class="block text-gray-700 font-bold mb-2" for="{kebab_column_name}">{capitalized_human_readable_column_name}</label>',  # noqa
+            f'\\1    <input type="text" class="input w-full" id="{kebab_column_name}" placeholder="{capitalized_human_readable_column_name}" bind:value='
+            + "{row."
+            + snake_column_name
+            + "} />",  # noqa
+            "\\1</div>",
+            "\\1\\2",
+        ]
     )
-    task.print_out(f'Write modified HTML to: {list_page_file_path}')
+    html_content = re.sub(field_regex, field_subst, html_content, 0, re.MULTILINE)
+    task.print_out(f"Write modified HTML to: {list_page_file_path}")
     await write_text_file_async(list_page_file_path, html_content)
 
 
@@ -58,27 +68,40 @@ async def add_column_to_update_page(
     kebab_entity_name: str,
     kebab_column_name: str,
     snake_column_name: str,
-    capitalized_human_readable_column_name: str
+    capitalized_human_readable_column_name: str,
 ):
     list_page_file_path = os.path.join(
-        project_dir, 'src', kebab_app_name, 'src', 'frontend', 'src', 'routes',
-        kebab_module_name, kebab_entity_name, 'update', '[id]', '+page.svelte'
+        project_dir,
+        "src",
+        kebab_app_name,
+        "src",
+        "frontend",
+        "src",
+        "routes",
+        kebab_module_name,
+        kebab_entity_name,
+        "update",
+        "[id]",
+        "+page.svelte",
     )
-    task.print_out(f'Read HTML from: {list_page_file_path}')
+    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')
+    task.print_out("Add field to update page")
     regex = r"(.*)(<!-- DON'T DELETE: insert new field here-->)"
-    subst = '\\n'.join([
-        '\\1<div class="mb-4">',
-        f'\\1    <label class="block text-gray-700 font-bold mb-2" for="{kebab_column_name}">{capitalized_human_readable_column_name}</label>', # noqa
-        f'\\1    <input type="text" class="input w-full" id="{kebab_column_name}" placeholder="{capitalized_human_readable_column_name}" bind:value=' + '{row.' + snake_column_name + '} />', # noqa
-        '\\1</div>',
-        '\\1\\2'
-    ])
-    html_content = re.sub(
-        regex, subst, html_content, 0, re.MULTILINE
+    subst = "\\n".join(
+        [
+            '\\1<div class="mb-4">',
+            f'\\1    <label class="block text-gray-700 font-bold mb-2" for="{kebab_column_name}">{capitalized_human_readable_column_name}</label>',  # noqa
+            f'\\1    <input type="text" class="input w-full" id="{kebab_column_name}" placeholder="{capitalized_human_readable_column_name}" bind:value='
+            + "{row."
+            + snake_column_name
+            + "} />",  # noqa
+            "\\1</div>",
+            "\\1\\2",
+        ]
     )
-    task.print_out(f'Write modified HTML to: {list_page_file_path}')
+    html_content = re.sub(regex, subst, html_content, 0, re.MULTILINE)
+    task.print_out(f"Write modified HTML to: {list_page_file_path}")
     await write_text_file_async(list_page_file_path, html_content)
 
 
@@ -91,27 +114,40 @@ async def add_column_to_delete_page(
     kebab_entity_name: str,
     kebab_column_name: str,
     snake_column_name: str,
-    capitalized_human_readable_column_name: str
+    capitalized_human_readable_column_name: str,
 ):
     list_page_file_path = os.path.join(
-        project_dir, 'src', kebab_app_name, 'src', 'frontend', 'src', 'routes',
-        kebab_module_name, kebab_entity_name, 'delete', '[id]', '+page.svelte'
+        project_dir,
+        "src",
+        kebab_app_name,
+        "src",
+        "frontend",
+        "src",
+        "routes",
+        kebab_module_name,
+        kebab_entity_name,
+        "delete",
+        "[id]",
+        "+page.svelte",
     )
-    task.print_out(f'Read HTML from: {list_page_file_path}')
+    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 delete page')
+    task.print_out("Add field to delete page")
     regex = r"(.*)(<!-- DON'T DELETE: insert new field here-->)"
-    subst = '\\n'.join([
-        '\\1<div class="mb-4">',
-        f'\\1    <label class="block text-gray-700 font-bold mb-2" for="{kebab_column_name}">{capitalized_human_readable_column_name}</label>', # noqa
-        f'\\1    <span id="{kebab_column_name}">' + '{row.' + snake_column_name + '}</span>', # noqa
-        '\\1</div>',
-        '\\1\\2'
-    ])
-    html_content = re.sub(
-        regex, subst, html_content, 0, re.MULTILINE
+    subst = "\\n".join(
+        [
+            '\\1<div class="mb-4">',
+            f'\\1    <label class="block text-gray-700 font-bold mb-2" for="{kebab_column_name}">{capitalized_human_readable_column_name}</label>',  # noqa
+            f'\\1    <span id="{kebab_column_name}">'
+            + "{row."
+            + snake_column_name
+            + "}</span>",  # noqa
+            "\\1</div>",
+            "\\1\\2",
+        ]
     )
-    task.print_out(f'Write modified HTML to: {list_page_file_path}')
+    html_content = re.sub(regex, subst, html_content, 0, re.MULTILINE)
+    task.print_out(f"Write modified HTML to: {list_page_file_path}")
     await write_text_file_async(list_page_file_path, html_content)
 
 
@@ -124,27 +160,40 @@ async def add_column_to_detail_page(
     kebab_entity_name: str,
     kebab_column_name: str,
     snake_column_name: str,
-    capitalized_human_readable_column_name: str
+    capitalized_human_readable_column_name: str,
 ):
     list_page_file_path = os.path.join(
-        project_dir, 'src', kebab_app_name, 'src', 'frontend', 'src', 'routes',
-        kebab_module_name, kebab_entity_name, 'detail', '[id]', '+page.svelte'
+        project_dir,
+        "src",
+        kebab_app_name,
+        "src",
+        "frontend",
+        "src",
+        "routes",
+        kebab_module_name,
+        kebab_entity_name,
+        "detail",
+        "[id]",
+        "+page.svelte",
     )
-    task.print_out(f'Read HTML from: {list_page_file_path}')
+    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 detail page')
+    task.print_out("Add field to detail page")
     regex = r"(.*)(<!-- DON'T DELETE: insert new field here-->)"
-    subst = '\\n'.join([
-        '\\1<div class="mb-4">',
-        f'\\1    <label class="block text-gray-700 font-bold mb-2" for="{kebab_column_name}">{capitalized_human_readable_column_name}</label>', # noqa
-        f'\\1    <span id="{kebab_column_name}">' + '{row.' + snake_column_name + '}</span>',  # noqa
-        '\\1</div>',
-        '\\1\\2'
-    ])
-    html_content = re.sub(
-        regex, subst, html_content, 0, re.MULTILINE
+    subst = "\\n".join(
+        [
+            '\\1<div class="mb-4">',
+            f'\\1    <label class="block text-gray-700 font-bold mb-2" for="{kebab_column_name}">{capitalized_human_readable_column_name}</label>',  # noqa
+            f'\\1    <span id="{kebab_column_name}">'
+            + "{row."
+            + snake_column_name
+            + "}</span>",  # noqa
+            "\\1</div>",
+            "\\1\\2",
+        ]
     )
-    task.print_out(f'Write modified HTML to: {list_page_file_path}')
+    html_content = re.sub(regex, subst, html_content, 0, re.MULTILINE)
+    task.print_out(f"Write modified HTML to: {list_page_file_path}")
     await write_text_file_async(list_page_file_path, html_content)
 
 
@@ -156,35 +205,35 @@ async def add_column_to_list_page(
     kebab_module_name: str,
     kebab_entity_name: str,
     snake_column_name: str,
-    capitalized_human_readable_column_name: str
+    capitalized_human_readable_column_name: str,
 ):
     list_page_file_path = os.path.join(
-        project_dir, 'src', kebab_app_name, 'src', 'frontend', 'src', 'routes',
-        kebab_module_name, kebab_entity_name, '+page.svelte'
+        project_dir,
+        "src",
+        kebab_app_name,
+        "src",
+        "frontend",
+        "src",
+        "routes",
+        kebab_module_name,
+        kebab_entity_name,
+        "+page.svelte",
     )
-    task.print_out(f'Read HTML from: {list_page_file_path}')
+    task.print_out(f"Read HTML from: {list_page_file_path}")
     html_content = await read_text_file_async(list_page_file_path)
     # process header
-    task.print_out('Add column header to table')
+    task.print_out("Add column header to table")
     header_regex = r"(.*)(<!-- DON'T DELETE: insert new column header here-->)"
-    header_subst = '\\n'.join([
-        f'\\1<th>{capitalized_human_readable_column_name}</th>',
-        '\\1\\2'
-    ])
-    html_content = re.sub(
-        header_regex, header_subst, html_content, 0, re.MULTILINE
+    header_subst = "\\n".join(
+        [f"\\1<th>{capitalized_human_readable_column_name}</th>", "\\1\\2"]
     )
+    html_content = re.sub(header_regex, header_subst, html_content, 0, re.MULTILINE)
     # process column
-    task.print_out('Add column to table')
+    task.print_out("Add column to table")
     column_regex = r"(.*)(<!-- DON'T DELETE: insert new column here-->)"
-    column_subst = '\\n'.join([
-        '\\1<td>{row.' + snake_column_name + '}</td>',
-        '\\1\\2'
-    ])
-    html_content = re.sub(
-        column_regex, column_subst, html_content, 0, re.MULTILINE
-    )
-    task.print_out(f'Write modified HTML to: {list_page_file_path}')
+    column_subst = "\\n".join(["\\1<td>{row." + snake_column_name + "}</td>", "\\1\\2"])
+    html_content = re.sub(column_regex, column_subst, html_content, 0, re.MULTILINE)
+    task.print_out(f"Write modified HTML to: {list_page_file_path}")
     await write_text_file_async(list_page_file_path, html_content)
 
 
@@ -196,29 +245,30 @@ async def add_column_to_test(
     snake_module_name: str,
     snake_entity_name: str,
     snake_column_name: str,
-    column_type: str
+    column_type: str,
 ):
     test_file_path = os.path.join(
-        project_dir, 'src', kebab_app_name, 'test', snake_module_name,
-        f'test_{snake_entity_name}.py'
+        project_dir,
+        "src",
+        kebab_app_name,
+        "test",
+        snake_module_name,
+        f"test_{snake_entity_name}.py",
     )
-    task.print_out(f'Read code from: {test_file_path}')
+    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'
-    )
+    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'
+        "inserted_success_data",
+        "to_be_updated_success_data",
+        "updated_success_data",
+        "to_be_deleted_success_data",
     ]
     for dict_name in dict_names:
         code = add_key_value_to_dict(
-            code=code,
-            dict_name=dict_name,
-            key=f"'{snake_column_name}'",
-            value="''"
+            code=code, dict_name=dict_name, key=f"'{snake_column_name}'", value="''"
         )
-    task.print_out(f'Write modified code to: {test_file_path}')
+    task.print_out(f"Write modified code to: {test_file_path}")
     await write_text_file_async(test_file_path, code)
 
 
@@ -231,24 +281,28 @@ async def add_column_to_schema(
     snake_entity_name: str,
     pascal_entity_name: str,
     snake_column_name: str,
-    column_type: str
+    column_type: str,
 ):
     schema_file_path = os.path.join(
-        project_dir, 'src', kebab_app_name, 'src', 'module', snake_module_name,
-        'schema', f'{snake_entity_name}.py'
+        project_dir,
+        "src",
+        kebab_app_name,
+        "src",
+        "module",
+        snake_module_name,
+        "schema",
+        f"{snake_entity_name}.py",
     )
-    task.print_out(f'Read code from: {schema_file_path}')
+    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'
-    )
+    task.print_out(f'Add column "{snake_column_name}" to the schema')
     code = add_property_to_class(
         code=code,
-        class_name=f'{pascal_entity_name}Data',
+        class_name=f"{pascal_entity_name}Data",
         property_name=snake_column_name,
-        property_type='str'
+        property_type="str",
     )
-    task.print_out(f'Write modified code to: {schema_file_path}')
+    task.print_out(f"Write modified code to: {schema_file_path}")
     await write_text_file_async(schema_file_path, code)
 
 
@@ -261,23 +315,28 @@ async def add_column_to_repo(
     snake_entity_name: str,
     pascal_entity_name: str,
     snake_column_name: str,
-    column_type: str
+    column_type: str,
 ):
     repo_file_path = os.path.join(
-        project_dir, 'src', kebab_app_name, 'src', 'module', snake_module_name,
-        'entity', snake_entity_name, 'repo.py'
+        project_dir,
+        "src",
+        kebab_app_name,
+        "src",
+        "module",
+        snake_module_name,
+        "entity",
+        snake_entity_name,
+        "repo.py",
     )
-    task.print_out(f'Read code from: {repo_file_path}')
+    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'
-    )
+    task.print_out(f'Add column "{snake_column_name}" to the repo')
     code = add_property_to_class(
         code=code,
-        class_name=f'DBEntity{pascal_entity_name}',
+        class_name=f"DBEntity{pascal_entity_name}",
         property_name=snake_column_name,
-        property_type='Column',
-        property_value='Column(String)'
+        property_type="Column",
+        property_value="Column(String)",
     )
-    task.print_out(f'Write modified code to: {repo_file_path}')
+    task.print_out(f"Write modified code to: {repo_file_path}")
     await write_text_file_async(repo_file_path, code)

zrb/builtin/generator/fastapp_module/add.py

@@ -1,22 +1,29 @@
-from zrb.helper.typing import Any
-from zrb.builtin.generator.fastapp_module.helper import (
-    create_microservice_config, register_module, register_migration,
-    create_app_config, append_all_enabled_env, append_all_disabled_env,
-    append_src_template_env, append_deployment_template_env
-)
+import asyncio
+import os
+
 from zrb.builtin.generator.common.helper import validate_existing_project_dir
 from zrb.builtin.generator.common.task_input import (
-    project_dir_input, app_name_input, module_name_input
+    app_name_input,
+    module_name_input,
+    project_dir_input,
+)
+from zrb.builtin.generator.fastapp_module.helper import (
+    append_all_disabled_env,
+    append_all_enabled_env,
+    append_deployment_template_env,
+    append_src_template_env,
+    create_app_config,
+    create_microservice_config,
+    register_migration,
+    register_module,
 )
 from zrb.builtin.group import project_add_group
-from zrb.task.task import Task
+from zrb.helper import util
+from zrb.helper.typing import Any
+from zrb.runner import runner
 from zrb.task.decorator import python_task
 from zrb.task.resource_maker import ResourceMaker
-from zrb.runner import runner
-from zrb.helper import util
-
-import asyncio
-import os
+from zrb.task.task import Task
 
 CURRENT_DIR = os.path.dirname(__file__)
 
@@ -26,35 +33,31 @@ CURRENT_DIR = os.path.dirname(__file__)
 
 
 @python_task(
-    name='validate',
+    name="validate",
     inputs=[project_dir_input, app_name_input, module_name_input],
     retry=0,
 )
 async def validate(*args: Any, **kwargs: Any):
-    project_dir = kwargs.get('project_dir')
+    project_dir = kwargs.get("project_dir")
     validate_existing_project_dir(project_dir)
-    app_name = kwargs.get('app_name')
-    module_name = kwargs.get('module_name')
+    app_name = kwargs.get("app_name")
+    module_name = kwargs.get("module_name")
     snake_module_name = util.to_snake_case(module_name)
     automation_dir = os.path.join(
-        project_dir, '_automate', util.to_snake_case(app_name)
+        project_dir, "_automate", util.to_snake_case(app_name)
     )
     if not os.path.exists(automation_dir):
-        raise Exception(
-            f'Automation directory does not exist: {automation_dir}'
-        )
-    app_dir = os.path.join(
-        project_dir, 'src', f'{util.to_kebab_case(app_name)}'
-    )
+        raise Exception(f"Automation directory does not exist: {automation_dir}")
+    app_dir = os.path.join(project_dir, "src", f"{util.to_kebab_case(app_name)}")
     if not os.path.exists(app_dir):
-        raise Exception(f'App directory does not exist: {app_dir}')
-    module_path = os.path.join(app_dir, 'src', 'module', snake_module_name)
+        raise Exception(f"App directory does not exist: {app_dir}")
+    module_path = os.path.join(app_dir, "src", "module", snake_module_name)
     if os.path.exists(module_path):
-        raise Exception(f'Module directory already exists: {module_path}')
+        raise Exception(f"Module directory already exists: {module_path}")
 
 
 copy_resource = ResourceMaker(
-    name='copy-resource',
+    name="copy-resource",
     inputs=[
         project_dir_input,
         app_name_input,
@@ -62,59 +65,79 @@ copy_resource = ResourceMaker(
     ],
     upstreams=[validate],
     replacements={
-        'zrbAppName': '{{input.app_name}}',
-        'zrbModuleName': '{{input.module_name}}',
+        "zrbAppName": "{{input.app_name}}",
+        "zrbModuleName": "{{input.module_name}}",
     },
-    template_path=os.path.join(CURRENT_DIR, 'template'),
-    destination_path='{{ input.project_dir }}',
+    template_path=os.path.join(CURRENT_DIR, "template"),
+    destination_path="{{ input.project_dir }}",
     excludes=[
-        '*/__pycache__',
-    ]
+        "*/__pycache__",
+    ],
 )
 
 
 @python_task(
-    name='fastapp-module',
+    name="fastapp-module",
     group=project_add_group,
     upstreams=[copy_resource],
-    runner=runner
+    runner=runner,
 )
 async def add_fastapp_module(*args: Any, **kwargs: Any):
-    task: Task = kwargs.get('_task')
-    project_dir = kwargs.get('project_dir', '.')
-    app_name = kwargs.get('app_name')
-    module_name = kwargs.get('module_name')
+    task: Task = kwargs.get("_task")
+    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
-        )),
-        asyncio.create_task(register_migration(
-            task, project_dir, kebab_app_name, snake_module_name
-        )),
-        asyncio.create_task(create_app_config(
-            task, project_dir, kebab_app_name, snake_module_name,
-            upper_snake_module_name
-        )),
-        asyncio.create_task(append_all_enabled_env(
-            task, project_dir, kebab_app_name, upper_snake_module_name
-        )),
-        asyncio.create_task(append_all_disabled_env(
-            task, project_dir, kebab_app_name, upper_snake_module_name
-        )),
-        asyncio.create_task(append_src_template_env(
-            task, project_dir, kebab_app_name, upper_snake_module_name
-        )),
-        asyncio.create_task(append_deployment_template_env(
-            task, project_dir, kebab_app_name, upper_snake_module_name
-        )),
+        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)
+        ),
+        asyncio.create_task(
+            register_migration(task, project_dir, kebab_app_name, snake_module_name)
+        ),
+        asyncio.create_task(
+            create_app_config(
+                task,
+                project_dir,
+                kebab_app_name,
+                snake_module_name,
+                upper_snake_module_name,
+            )
+        ),
+        asyncio.create_task(
+            append_all_enabled_env(
+                task, project_dir, kebab_app_name, upper_snake_module_name
+            )
+        ),
+        asyncio.create_task(
+            append_all_disabled_env(
+                task, project_dir, kebab_app_name, upper_snake_module_name
+            )
+        ),
+        asyncio.create_task(
+            append_src_template_env(
+                task, project_dir, kebab_app_name, upper_snake_module_name
+            )
+        ),
+        asyncio.create_task(
+            append_deployment_template_env(
+                task, project_dir, kebab_app_name, upper_snake_module_name
+            )
+        ),
     )
-    task.print_out('Success')
+    task.print_out("Success")