zrb 1.0.0a15__py3-none-any.whl → 1.0.0a17__py3-none-any.whl

zrb/__main__.py

@@ -14,6 +14,9 @@ def serve_cli():
         for init_script in INIT_SCRIPTS:
             load_file(init_script, -1)
         cli.run(sys.argv[1:])
+    except RuntimeError as e:
+        if "Event loop is closed" not in f"{e}":
+            raise e
     except KeyboardInterrupt:
         print(stylize_warning("\nStopped"), file=sys.stderr)
     except NodeNotFoundError as e:

zrb/builtin/__init__.py

@@ -9,8 +9,8 @@ from zrb.builtin.git import (
 from zrb.builtin.git_subtree import git_add_subtree, git_pull_subtree, git_push_subtree
 from zrb.builtin.llm.llm_chat import llm_chat
 from zrb.builtin.md5 import hash_md5, sum_md5
-from zrb.builtin.project.add.fastapp import add_fastapp_to_project
-from zrb.builtin.project.create.create import create_project
+from zrb.builtin.project.add.fastapp.fastapp_task import add_fastapp_to_project
+from zrb.builtin.project.create.project_task import create_project
 from zrb.builtin.python import format_python_code
 from zrb.builtin.setup.asdf.asdf import setup_asdf
 from zrb.builtin.setup.latex.ubuntu import setup_latex_on_ubuntu

zrb/builtin/git.py

@@ -3,7 +3,7 @@ from zrb.context.any_context import AnyContext
 from zrb.input.bool_input import BoolInput
 from zrb.input.str_input import StrInput
 from zrb.task.make_task import make_task
-from zrb.util.cli.style import stylize_green, stylize_red, stylize_yellow
+from zrb.util.cli.style import stylize_faint, stylize_green, stylize_red, stylize_yellow
 from zrb.util.git import (
     add,
     commit,
@@ -56,6 +56,7 @@ from zrb.util.git import (
     alias="diff",
 )
 async def get_git_diff(ctx: AnyContext):
+    ctx.print(stylize_faint("Get directory"))
     repo_dir = await get_repo_dir(log_method=ctx.print)
     diff = await get_diff(
         repo_dir, ctx.input.source, ctx.input.current, log_method=ctx.print
@@ -86,13 +87,16 @@ async def get_git_diff(ctx: AnyContext):
     alias="prune",
 )
 async def prune_local_branches(ctx: AnyContext):
+    ctx.print(stylize_faint("Get directory"))
     repo_dir = await get_repo_dir(log_method=ctx.print)
+    ctx.print(stylize_faint("Get existing branches"))
     branches = await get_branches(repo_dir, log_method=ctx.print)
+    ctx.print(stylize_faint("Get current branch"))
     current_branch = await get_current_branch(repo_dir, log_method=ctx.print)
     for branch in branches:
         if branch == current_branch or branch == "main" or branch == "master":
             continue
-        ctx.print(stylize_yellow(f"Removing local branch: {branch}"))
+        ctx.print(stylize_faint(f"Removing local branch: {branch}"))
         try:
             await delete_branch(repo_dir, branch, log_method=ctx.print)
         except Exception as e:
@@ -112,10 +116,11 @@ async def prune_local_branches(ctx: AnyContext):
     alias="commit",
 )
 async def git_commit(ctx: AnyContext):
+    ctx.print(stylize_faint("Get directory"))
     repo_dir = await get_repo_dir(log_method=ctx.print)
-    ctx.print("Add changes to staging")
+    ctx.print(stylize_faint("Add changes to staging"))
     await add(repo_dir, log_method=ctx.print)
-    ctx.print("Commit changes")
+    ctx.print(stylize_faint("Commit changes"))
     await commit(repo_dir, ctx.input.message, log_method=ctx.print)
 
 
@@ -133,10 +138,12 @@ async def git_commit(ctx: AnyContext):
     alias="pull",
 )
 async def git_pull(ctx: AnyContext):
+    ctx.print(stylize_faint("Get directory"))
     repo_dir = await get_repo_dir(log_method=ctx.print)
-    remote = ctx.input.remote
+    ctx.print(stylize_faint("Get current branch"))
     current_branch = await get_current_branch(repo_dir, log_method=ctx.print)
-    ctx.print(f"Pulling from {remote}/{current_branch}")
+    remote = ctx.input.remote
+    ctx.print(stylize_faint(f"Pulling from {remote}/{current_branch}"))
     await pull(repo_dir, remote, current_branch, log_method=ctx.print)
 
 
@@ -155,7 +162,8 @@ async def git_pull(ctx: AnyContext):
 )
 async def git_push(ctx: AnyContext):
     repo_dir = await get_repo_dir(log_method=ctx.print)
-    remote = ctx.input.remote
+    ctx.print(stylize_faint("Get current branch"))
     current_branch = await get_current_branch(repo_dir, log_method=ctx.print)
-    ctx.print(f"Pushing to {remote}/{current_branch}")
+    remote = ctx.input.remote
+    ctx.print(stylize_faint(f"Pushing to {remote}/{current_branch}"))
     await push(repo_dir, remote, current_branch, log_method=ctx.print)

zrb/builtin/git_subtree.py

@@ -3,6 +3,7 @@ from zrb.builtin.group import git_subtree_group
 from zrb.context.any_context import AnyContext
 from zrb.input.str_input import StrInput
 from zrb.task.make_task import make_task
+from zrb.util.cli.style import stylize_faint
 from zrb.util.git import get_repo_dir
 from zrb.util.git_subtree import add_subtree, load_config, pull_subtree, push_subtree
 
@@ -33,7 +34,9 @@ from zrb.util.git_subtree import add_subtree, load_config, pull_subtree, push_su
     alias="add",
 )
 async def git_add_subtree(ctx: AnyContext):
+    ctx.print(stylize_faint("Get directory"))
     repo_dir = await get_repo_dir(log_method=ctx.print)
+    ctx.print(stylize_faint("Add subtree"))
     await add_subtree(
         repo_dir=repo_dir,
         name=ctx.input.name,
@@ -52,6 +55,7 @@ async def git_add_subtree(ctx: AnyContext):
     alias="pull",
 )
 async def git_pull_subtree(ctx: AnyContext):
+    ctx.print(stylize_faint("Get directory"))
     repo_dir = await get_repo_dir(log_method=ctx.print)
     config = load_config(repo_dir)
     if not config.data:
@@ -59,7 +63,7 @@ async def git_pull_subtree(ctx: AnyContext):
     first_err: Exception | None = None
     for name, detail in config.data.items():
         try:
-            ctx.print(f"Pull from subtree {name}")
+            ctx.print(stylize_faint(f"Pull from subtree {name}"))
             await pull_subtree(
                 repo_dir=repo_dir,
                 prefix=detail.prefix,
@@ -83,6 +87,7 @@ async def git_pull_subtree(ctx: AnyContext):
     alias="push",
 )
 async def git_push_subtree(ctx: AnyContext):
+    ctx.print(stylize_faint("Get directory"))
     repo_dir = await get_repo_dir(log_method=ctx.print)
     config = load_config(repo_dir)
     if not config.data:
@@ -90,7 +95,7 @@ async def git_push_subtree(ctx: AnyContext):
     first_err: Exception | None = None
     for name, detail in config.data.items():
         try:
-            ctx.print(f"Push to subtree {name}")
+            ctx.print(stylize_faint(f"Push to subtree {name}"))
             await push_subtree(
                 repo_dir=repo_dir,
                 prefix=detail.prefix,

zrb/builtin/llm/tool/rag.py

@@ -12,6 +12,7 @@ from zrb.config import (
     RAG_OVERLAP,
 )
 from zrb.util.cli.style import stylize_error, stylize_faint
+from zrb.util.file import read_file
 from zrb.util.run import run_async
 
 Document = str | Callable[[], str]
@@ -137,8 +138,7 @@ def get_rag_documents(document_dir_path: str) -> Callable[[], list[Callable[[],
 def _get_text_reader(file_path: str):
     def read():
         print(stylize_faint(f"Start reading {file_path}"), file=sys.stderr)
-        with open(file_path, "r", encoding="utf-8") as f:
-            content = f.read()
+        content = read_file(file_path)
         print(stylize_faint(f"Complete reading {file_path}"), file=sys.stderr)
         return content
 

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

@@ -0,0 +1,16 @@
+import os
+
+from zrb.input.str_input import StrInput
+
+project_dir_input = StrInput(
+    name="project-dir",
+    description="Project directory",
+    prompt="Project directory",
+    default_str=lambda _: os.getcwd(),
+)
+
+app_name_input = StrInput(
+    name="app",
+    description="App name",
+    prompt="App name",
+)

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

@@ -0,0 +1,92 @@
+import os
+
+from zrb.builtin.group import add_to_project_group
+from zrb.builtin.project.add.fastapp.fastapp_input import (
+    app_name_input,
+    project_dir_input,
+)
+from zrb.builtin.project.add.fastapp.fastapp_util import (
+    get_zrb_init_import_code,
+    get_zrb_init_load_app_name_task,
+)
+from zrb.context.any_context import AnyContext
+from zrb.task.make_task import make_task
+from zrb.task.scaffolder import Scaffolder
+from zrb.task.task import Task
+from zrb.util.file import read_file, write_file
+from zrb.util.string.conversion import to_snake_case
+from zrb.util.string.name import get_random_name
+
+_DIR = os.path.dirname(__file__)
+
+
+@make_task(
+    name="validate-create-fastapp",
+    input=[project_dir_input, app_name_input],
+    retries=0,
+)
+async def validate_create_fastapp(ctx: AnyContext):
+    project_dir = ctx.input.project_dir
+    if not os.path.isdir(project_dir):
+        raise ValueError(f"Project directory not exists: {project_dir}")
+    app_dir = os.path.join(project_dir, to_snake_case(ctx.input.app))
+    if os.path.exists(app_dir):
+        raise ValueError(f"Application directory already exists: {app_dir}")
+
+
+scaffold_fastapp = Scaffolder(
+    name="scaffold-fastapp",
+    input=[
+        project_dir_input,
+        app_name_input,
+    ],
+    upstream=validate_create_fastapp,
+    source_path=os.path.join(_DIR, "fastapp_template"),
+    render_source_path=False,
+    destination_path=lambda ctx: os.path.join(
+        ctx.input.project_dir, to_snake_case(ctx.input.app)
+    ),
+    transform_content={
+        "fastapp_template": "{to_snake_case(ctx.input.app)}",
+        "My App Name": "{ctx.input.app.title()}",
+        "my-app-name": "{to_kebab_case(ctx.input.app)}",
+        "my_app_name": "{to_snake_case(ctx.input.app)}",
+        "MY_APP_NAME": "{to_snake_case(ctx.input.app).upper()}",
+        "my-secure-password": lambda _: get_random_name(),
+    },
+    retries=0,
+)
+
+
+@make_task(
+    name="update-fastapp-zrb-init",
+    input=[
+        project_dir_input,
+        app_name_input,
+    ],
+    upstream=scaffold_fastapp,
+    retries=0,
+)
+def update_fastapp_zrb_init(ctx: AnyContext):
+    zrb_init_path = os.path.join(ctx.input.project_dir, "zrb_init.py")
+    old_zrb_init_code = read_file(zrb_init_path)
+    write_file(
+        file_path=zrb_init_path,
+        content=[
+            get_zrb_init_import_code(old_zrb_init_code),
+            old_zrb_init_code.strip(),
+            get_zrb_init_load_app_name_task(ctx.input.app),
+            "",
+        ],
+    )
+
+
+add_fastapp_to_project = add_to_project_group.add_task(
+    Task(
+        name="add-fastapp",
+        description="🚀 Add FastApp to project",
+        upstream=update_fastapp_zrb_init,
+        retries=0,
+    ),
+    alias="fastapp",
+)

zrb/builtin/project/add/fastapp/fastapp_template/_zrb/entity/any_client_method.template.py

@@ -0,0 +1,27 @@
+@abstractmethod
+async def get_my_entity_by_id(self, my_entity_id: str) -> MyEntityResponse:
+    pass
+
+
+@abstractmethod
+async def get_all_my_entitys(self) -> list[MyEntityResponse]:
+    pass
+
+
+@abstractmethod
+async def create_my_entity(
+    self, data: MyEntityCreateWithAudit | list[MyEntityCreateWithAudit]
+) -> MyEntityResponse | list[MyEntityResponse]:
+    pass
+
+
+@abstractmethod
+async def update_my_entity(
+    self, my_entity_id: str, data: MyEntityUpdateWithAudit
+) -> MyEntityResponse:
+    pass
+
+
+@abstractmethod
+async def delete_my_entity(self, my_entity_id: str) -> MyEntityResponse:
+    pass

zrb/builtin/project/add/{fastapp_template → fastapp/fastapp_template}/_zrb/entity/module_template/service/my_entity/my_entity_usecase.py

@@ -2,13 +2,13 @@ from fastapp_template.common.base_usecase import BaseUsecase
 from fastapp_template.module.my_module.service.my_entity.repository.factory import (
     my_entity_repository,
 )
-from fastapp_template.module.my_module.service.my_entity.repository.repository import (
+from fastapp_template.module.my_module.service.my_entity.repository.my_entity_repository import (
     MyEntityRepository,
 )
 from fastapp_template.schema.my_entity import (
-    MyEntityCreate,
+    MyEntityCreateWithAudit,
     MyEntityResponse,
-    MyEntityUpdate,
+    MyEntityUpdateWithAudit,
 )
 
 
@@ -38,9 +38,9 @@ class MyEntityUsecase(BaseUsecase):
         response_model=MyEntityResponse | list[MyEntityResponse],
     )
     async def create_my_entity(
-        self, data: MyEntityCreate | list[MyEntityCreate]
+        self, data: MyEntityCreateWithAudit | list[MyEntityCreateWithAudit]
     ) -> MyEntityResponse | list[MyEntityResponse]:
-        if isinstance(data, MyEntityCreate):
+        if isinstance(data, MyEntityCreateWithAudit):
             return await self.my_entity_repository.create(data)
         return await self.my_entity_repository.create_bulk(data)
 
@@ -50,7 +50,7 @@ class MyEntityUsecase(BaseUsecase):
         response_model=MyEntityResponse,
     )
     async def update_my_entity(
-        self, my_entity_id: str, data: MyEntityUpdate
+        self, my_entity_id: str, data: MyEntityUpdateWithAudit
     ) -> MyEntityResponse:
         return await self.my_entity_repository.update(my_entity_id, data)
 

zrb/builtin/project/add/{fastapp_template → fastapp/fastapp_template}/_zrb/entity/module_template/service/my_entity/repository/my_entity_db_repository.py

@@ -5,9 +5,9 @@ from fastapp_template.module.my_module.service.my_entity.repository.my_entity_re
 )
 from fastapp_template.schema.my_entity import (
     MyEntity,
-    MyEntityCreate,
+    MyEntityCreateWithAudit,
     MyEntityResponse,
-    MyEntityUpdate,
+    MyEntityUpdateWithAudit,
 )
 from passlib.context import CryptContext
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -22,12 +22,17 @@ def hash_password(password: str) -> str:
 
 
 class MyEntityDBRepository(
-    BaseDBRepository[MyEntity, MyEntityResponse, MyEntityCreate, MyEntityUpdate],
+    BaseDBRepository[
+        MyEntity,
+        MyEntityResponse,
+        MyEntityCreateWithAudit,
+        MyEntityUpdateWithAudit,
+    ],
     MyEntityRepository,
 ):
     db_model = MyEntity
     response_model = MyEntityResponse
-    create_model = MyEntityCreate
-    update_model = MyEntityUpdate
+    create_model = MyEntityCreateWithAudit
+    update_model = MyEntityUpdateWithAudit
     entity_name = "my_entity"
     column_preprocessors = {}

zrb/builtin/project/add/{fastapp_template → fastapp/fastapp_template}/_zrb/entity/module_template/service/my_entity/repository/my_entity_repository.py

@@ -2,16 +2,16 @@ from abc import ABC, abstractmethod
 
 from fastapp_template.schema.my_entity import (
     MyEntity,
-    MyEntityCreate,
+    MyEntityCreateWithAudit,
     MyEntityResponse,
-    MyEntityUpdate,
+    MyEntityUpdateWithAudit,
 )
 
 
 class MyEntityRepository(ABC):
 
     @abstractmethod
-    async def create(self, my_entity_data: MyEntityCreate) -> MyEntityResponse:
+    async def create(self, my_entity_data: MyEntityCreateWithAudit) -> MyEntityResponse:
         pass
 
     @abstractmethod
@@ -24,7 +24,7 @@ class MyEntityRepository(ABC):
 
     @abstractmethod
     async def update(
-        self, my_entity_id: str, my_entity_data: MyEntityUpdate
+        self, my_entity_id: str, my_entity_data: MyEntityUpdateWithAudit
     ) -> MyEntity:
         pass
 
@@ -34,6 +34,6 @@ class MyEntityRepository(ABC):
 
     @abstractmethod
     async def create_bulk(
-        self, my_entity_data_list: list[MyEntityCreate]
+        self, my_entity_data_list: list[MyEntityCreateWithAudit]
     ) -> list[MyEntityResponse]:
         pass

zrb/builtin/project/add/{fastapp_template → fastapp/fastapp_template}/_zrb/entity/schema.template.py

@@ -12,10 +12,18 @@ class MyEntityCreate(MyEntityBase):
     pass
 
 
+class MyEntityCreateWithAudit(MyEntityCreate):
+    created_by: str
+
+
 class MyEntityUpdate(SQLModel):
     my_column: str | None = None
 
 
+class MyEntityUpdateWithAudit(MyEntityUpdate):
+    updated_by: str
+
+
 class MyEntityResponse(MyEntityBase):
     id: str
 

zrb/builtin/project/add/{fastapp_template/_zrb/entity/create_entity_task.py → fastapp/fastapp_template/_zrb/entity/task.py}

@@ -2,20 +2,23 @@ import os
 
 from fastapp_template._zrb.config import APP_DIR
 from fastapp_template._zrb.group import app_create_group
-from fastapp_template._zrb.helper import (
-    get_existing_module_names,
-    get_existing_schema_names,
-)
 from fastapp_template._zrb.input import (
     existing_module_input,
     new_entity_column_input,
     new_entity_input,
     plural_entity_input,
 )
+from fastapp_template._zrb.util import (
+    get_existing_module_names,
+    get_existing_schema_names,
+)
 
 from zrb import AnyContext, Scaffolder, Task, make_task
-from zrb.util.codemod.add_code_to_module import add_code_to_module
-from zrb.util.codemod.add_parent_to_class import add_parent_to_class
+from zrb.util.codemod.append_code_to_class import append_code_to_class
+from zrb.util.codemod.append_code_to_function import append_code_to_function
+from zrb.util.codemod.prepend_code_to_module import prepend_code_to_module
+from zrb.util.codemod.prepend_parent_to_class import prepend_parent_class
+from zrb.util.file import read_file, write_file
 from zrb.util.string.conversion import to_pascal_case, to_snake_case
 
 
@@ -81,6 +84,9 @@ scaffold_my_app_name_module_entity = Scaffolder(
         "my_entities": "{to_snake_case(ctx.input.plural)}",
         "my-entities": "{to_kebab_case(ctx.input.plural)}",
     },
+    transform_path={
+        "my_entity": "{to_snake_case(ctx.input.entity)}",
+    },
     retries=0,
     upstream=validate_create_my_app_name_entity,
 )
@@ -97,21 +103,19 @@ async def register_my_app_name_migration(ctx: AnyContext):
         APP_DIR, "module", to_snake_case(ctx.input.module), "migration_metadata.py"
     )
     app_name = os.path.basename(APP_DIR)
-    with open(migration_metadata_file_path, "r") as f:
-        file_content = f.read()
-    entity_name = to_snake_case(ctx.input.entity)
-    entity_class = to_pascal_case(ctx.input.entity)
+    file_content = read_file(migration_metadata_file_path)
+    snake_entity_name = to_snake_case(ctx.input.entity)
+    pascal_entity_name = to_pascal_case(ctx.input.entity)
     new_file_content_list = (
-        [f"from {app_name}.schema.{entity_name} import {entity_class}"]
+        [f"from {app_name}.schema.{snake_entity_name} import {pascal_entity_name}"]
         + file_content.strip()
         + [
-            f"{entity_class}.metadata = metadata",
-            f"{entity_class}.__table__.tometadata(metadata)",
+            f"{pascal_entity_name}.metadata = metadata",
+            f"{pascal_entity_name}.__table__.tometadata(metadata)",
             "",
         ]
     )
-    with open(migration_metadata_file_path, "w") as f:
-        f.write("\n".join(new_file_content_list))
+    write_file(migration_metadata_file_path, "\n".join(new_file_content_list))
 
 
 @make_task(
@@ -124,28 +128,28 @@ async def register_my_app_name_api_client(ctx: AnyContext):
     api_client_file_path = os.path.join(
         APP_DIR, "module", to_snake_case(ctx.input.module), "client", "api_client.py"
     )
-    with open(api_client_file_path, "r") as f:
-        file_content = f.read()
-    module_config_name = to_snake_case(ctx.input.module).upper()
-    new_code = add_code_to_module(
+    file_content = read_file(api_client_file_path)
+    upper_snake_module_name = to_snake_case(ctx.input.module).upper()
+    new_code = prepend_code_to_module(
         file_content,
-        f"user_api_client = user_usecase.as_api_client(base_url=APP_{module_config_name}_BASE_URL)",  # noqa
+        f"user_api_client = user_usecase.as_api_client(base_url=APP_{upper_snake_module_name}_BASE_URL)",  # noqa
     )
-    new_code = add_parent_to_class(
+    new_code = prepend_parent_class(
         original_code=new_code,
         class_name="APIClient",
         parent_class_name="user_api_client",
     )
     app_name = os.path.basename(APP_DIR)
-    entity_name = to_snake_case(ctx.input.entity)
-    module_name = to_snake_case(ctx.input.module)
-    new_file_content_list = [
-        f"from {app_name}.module.{module_name}.service.{entity_name} import {entity_name}_usecase",  # noqa
-        new_code.strip(),
-        "",
-    ]
-    with open(api_client_file_path, "w") as f:
-        f.write("\n".join(new_file_content_list))
+    snake_entity_name = to_snake_case(ctx.input.entity)
+    snake_module_name = to_snake_case(ctx.input.module)
+    write_file(
+        api_client_file_path,
+        [
+            f"from {app_name}.module.{snake_module_name}.service.{snake_entity_name}.{snake_entity_name}_usecase import {snake_entity_name}_usecase",  # noqa
+            new_code.strip(),
+            "",
+        ],
+    )
 
 
 @make_task(
@@ -158,26 +162,85 @@ async def register_my_app_name_direct_client(ctx: AnyContext):
     direct_client_file_path = os.path.join(
         APP_DIR, "module", to_snake_case(ctx.input.module), "client", "direct_client.py"
     )
-    with open(direct_client_file_path, "r") as f:
-        file_content = f.read()
-    new_code = add_code_to_module(
-        file_content, "user_direct_client = user_usecase.as_direct_client()"
+    file_content = read_file(direct_client_file_path)
+    app_name = os.path.basename(APP_DIR)
+    snake_entity_name = to_snake_case(ctx.input.entity)
+    snake_module_name = to_snake_case(ctx.input.module)
+    write_file(
+        direct_client_file_path,
+        [
+            f"from {app_name}.module.{snake_module_name}.service.{snake_entity_name}.{snake_entity_name}_usecase import {snake_entity_name}_usecase",  # noqa
+            prepend_code_to_module(
+                prepend_parent_class(
+                    file_content, "DirectClient", "user_direct_client"
+                ),
+                "user_direct_client = user_usecase.as_direct_client()",
+            ).strip(),
+            "",
+        ],
     )
-    new_code = add_parent_to_class(
-        original_code=new_code,
-        class_name="DirectClient",
-        parent_class_name="user_direct_client",
+
+
+@make_task(
+    name="register-my-app-name-route",
+    input=[existing_module_input, new_entity_input],
+    retries=0,
+    upstream=validate_create_my_app_name_entity,
+)
+async def register_my_app_name_route(ctx: AnyContext):
+    direct_client_file_path = os.path.join(
+        APP_DIR, "module", to_snake_case(ctx.input.module), "route.py"
     )
-    app_name = os.path.basename(APP_DIR)
+    file_content = read_file(direct_client_file_path)
     entity_name = to_snake_case(ctx.input.entity)
+    new_code = append_code_to_function(
+        file_content, "serve_route", f"{entity_name}_usecase.serve_route(app)"
+    )
+    app_name = os.path.basename(APP_DIR)
     module_name = to_snake_case(ctx.input.module)
     new_file_content_list = [
-        f"from {app_name}.module.{module_name}.service.{entity_name} import {entity_name}_usecase",  # noqa
+        f"from {app_name}.module.{module_name}.service.{entity_name}.{entity_name}_usecase import {entity_name}_usecase",  # noqa
         new_code.strip(),
         "",
     ]
-    with open(direct_client_file_path, "w") as f:
-        f.write("\n".join(new_file_content_list))
+    write_file(direct_client_file_path, "\n".join(new_file_content_list))
+
+
+@make_task(
+    name="register-my-app-name-client-method",
+    input=[existing_module_input, new_entity_input],
+    retries=0,
+    upstream=validate_create_my_app_name_entity,
+)
+async def register_my_app_name_client_method(ctx: AnyContext):
+    any_client_file_path = os.path.join(
+        APP_DIR, "module", to_snake_case(ctx.input.module), "route.py"
+    )
+    file_content = read_file(any_client_file_path)
+    app_name = os.path.basename(APP_DIR)
+    snake_entity_name = to_snake_case(ctx.input.entity)
+    pascal_entity_name = to_pascal_case(ctx.input.entity)
+    # TODO: Register client methods
+    # get methods
+    any_client_method_template_path = (
+        os.path.join(os.path.dirname(__file__), "any_client_method.template.py"),
+    )
+    any_client_method_template = read_file(any_client_method_template_path)
+    any_client_method = any_client_method_template.replace(
+        "my_entity", snake_entity_name
+    ).replace("MyEntity", pascal_entity_name)
+    new_code = append_code_to_class(file_content, "AnyClient", any_client_method)
+    new_file_content_list = [
+        f"from {app_name}.schema.{snake_entity_name}.{snake_entity_name} import (",
+        f"    {pascal_entity_name}CreateWithAudit, {pascal_entity_name}Response, {pascal_entity_name}UpdateWithAudit",
+        ")",
+        new_code.strip(),
+        "",
+    ]
+    write_file(any_client_file_path, "\n".join(new_file_content_list))
+
+
+# TODO: Register gateway route
 
 
 create_my_app_name_entity = app_create_group.add_task(
@@ -193,4 +256,5 @@ create_my_app_name_entity << [
     scaffold_my_app_name_module_entity,
     register_my_app_name_api_client,
     register_my_app_name_direct_client,
+    register_my_app_name_route,
 ]

zrb/builtin/project/add/{fastapp_template → fastapp/fastapp_template}/_zrb/input.py

@@ -1,4 +1,4 @@
-from fastapp_template._zrb.helper import (
+from fastapp_template._zrb.util import (
     get_existing_module_names,
     get_existing_schema_names,
 )