zrb 1.0.0a16__tar.gz → 1.0.0a20__tar.gz

{zrb-1.0.0a16 → zrb-1.0.0a20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zrb
-Version: 1.0.0a16
+Version: 1.0.0a20
 Summary: Your Automation Powerhouse
 Home-page: https://github.com/state-alchemists/zrb
 License: AGPL-3.0-or-later
@@ -18,12 +18,13 @@ Requires-Dist: autopep8 (>=2.0.4,<3.0.0)
 Requires-Dist: beautifulsoup4 (>=4.12.3,<5.0.0)
 Requires-Dist: black (>=24.10.0,<24.11.0)
 Requires-Dist: chromadb (>=0.5.20,<0.6.0) ; extra == "rag"
-Requires-Dist: fastapi[standard] (>=0.115.5,<0.116.0)
+Requires-Dist: fastapi[standard] (>=0.115.6,<0.116.0)
 Requires-Dist: isort (>=5.13.2,<5.14.0)
 Requires-Dist: libcst (>=1.5.0,<2.0.0)
 Requires-Dist: litellm (>=1.52.12,<2.0.0)
 Requires-Dist: pdfplumber (>=0.11.4,<0.12.0) ; extra == "rag"
 Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
+Requires-Dist: python-jose[cryptography] (>=3.3.0,<4.0.0)
 Requires-Dist: requests (>=2.32.3,<3.0.0)
 Project-URL: Documentation, https://github.com/state-alchemists/zrb
 Project-URL: Repository, https://github.com/state-alchemists/zrb

{zrb-1.0.0a16 → zrb-1.0.0a20}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "zrb"
-version = "1.0.0a16"
+version = "1.0.0a20"
 description = "Your Automation Powerhouse"
 authors = ["Go Frendi Gunawan <gofrendiasgard@gmail.com>"]
 license = "AGPL-3.0-or-later"
@@ -17,7 +17,6 @@ exclude = [
     ".venv",
     ".vscode",
     "dist",
-    "docker",
     "docs",
     "htmlcov",
     "playground",
@@ -49,7 +48,8 @@ litellm = "^1.52.12"
 chromadb = {version = "^0.5.20", optional = true}
 pdfplumber = {version = "^0.11.4", optional = true}
 beautifulsoup4 = "^4.12.3"
-fastapi = {extras = ["standard"], version = "^0.115.5"}
+fastapi = {extras = ["standard"], version = "^0.115.6"}
+python-jose = {extras = ["cryptography"], version = "^3.3.0"}
 
 [tool.poetry.extras]
 # poetry install -E rag
@@ -60,6 +60,7 @@ flake8 = "~7.1.1"
 pytest = "~8.3.3"
 pytest-cov = "~6.0.0"
 pytest-asyncio = "~0.24.0"
+tomlkit = "^0.13.2"
 
 [tool.pytest.ini_options]
 asyncio_default_fixture_loop_scope = "function"

{zrb-1.0.0a16 → zrb-1.0.0a20}/src/zrb/__init__.py

@@ -27,12 +27,14 @@ from zrb.group.group import Group
 from zrb.input.any_input import AnyInput
 from zrb.input.base_input import BaseInput
 from zrb.input.bool_input import BoolInput
+from zrb.input.float_input import FloatInput
 from zrb.input.int_input import IntInput
 from zrb.input.option_input import OptionInput
 from zrb.input.password_input import PasswordInput
 from zrb.input.str_input import StrInput
 from zrb.input.text_input import TextInput
 from zrb.runner.cli import cli
+from zrb.runner.web_config import User, web_config
 from zrb.session.session import Session
 from zrb.task.any_task import AnyTask
 from zrb.task.base_task import BaseTask
@@ -73,6 +75,7 @@ assert CmdResult
 assert CmdTask
 assert HttpCheck
 assert TcpCheck
+assert FloatInput
 assert IntInput
 assert OptionInput
 assert PasswordInput
@@ -98,6 +101,8 @@ assert Scaffolder
 assert Scheduler
 assert cli
 assert Xcom
+assert web_config
+assert User
 
 if LOAD_BUILTIN:
     from zrb import builtin

{zrb-1.0.0a16 → zrb-1.0.0a20}/src/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-1.0.0a16 → zrb-1.0.0a20}/src/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-1.0.0a16 → zrb-1.0.0a20}/src/zrb/builtin/git.py

@@ -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,8 +87,11 @@ 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":
@@ -112,6 +116,7 @@ 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(stylize_faint("Add changes to staging"))
     await add(repo_dir, log_method=ctx.print)
@@ -133,9 +138,11 @@ 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)
+    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)
+    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-1.0.0a16 → zrb-1.0.0a20}/src/zrb/builtin/git_subtree.py

@@ -34,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,
@@ -53,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:
@@ -84,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:

{zrb-1.0.0a16 → zrb-1.0.0a20}/src/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-1.0.0a20/src/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-1.0.0a20/src/zrb/builtin/project/add/fastapp/fastapp_task.py

@@ -0,0 +1,78 @@
+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 (
+    is_in_project_app_dir,
+    is_project_zrb_init_file,
+    update_project_zrb_init_file,
+)
+from zrb.content_transformer.content_transformer import ContentTransformer
+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.string.conversion import to_snake_case
+from zrb.util.string.name import get_random_name
+
+
+@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(os.path.dirname(__file__), "fastapp_template"),
+    render_source_path=False,
+    destination_path="{ctx.input.project_dir}",
+    transform_path={
+        "my_app_name": "{to_snake_case(ctx.input.app)}",
+    },
+    transform_content=[
+        # Common transformation (project_dir/app_dir/**/*)
+        ContentTransformer(
+            match=is_in_project_app_dir,
+            transform={
+                "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(),
+            },
+        ),
+        # Register fastapp's tasks to project's zrb_init (project_dir/zrb_init.py)
+        ContentTransformer(
+            match=is_project_zrb_init_file,
+            transform=update_project_zrb_init_file,
+        ),
+    ],
+    retries=0,
+)
+
+add_fastapp_to_project = add_to_project_group.add_task(
+    Task(
+        name="add-fastapp",
+        description="🚀 Add FastApp to project",
+        upstream=scaffold_fastapp,
+        retries=0,
+    ),
+    alias="fastapp",
+)

zrb-1.0.0a20/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/.flake8

@@ -0,0 +1,3 @@
+[flake8]
+max-line-length = 95
+extend-ignore = E203, E704

zrb-1.0.0a20/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/column/create_column_task.py

@@ -0,0 +1,14 @@
+from my_app_name._zrb.format_task import format_my_app_name_code
+from my_app_name._zrb.group import app_create_group
+
+from zrb import Task
+
+add_my_app_name_column = app_create_group.add_task(
+    Task(
+        name="add-my-app-name-column",
+        description="📊 Create new column on an entity",
+        successor=format_my_app_name_code,
+        retries=0,
+    ),
+    alias="column",
+)

zrb-1.0.0a20/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/entity/add_entity_task.py

@@ -0,0 +1,128 @@
+import os
+
+from my_app_name._zrb.config import APP_DIR
+from my_app_name._zrb.entity.add_entity_util import (
+    is_in_app_schema_dir,
+    is_in_module_entity_dir,
+    is_module_any_client_file,
+    is_module_api_client_file,
+    is_module_direct_client_file,
+    is_module_migration_metadata_file,
+    is_module_route_file,
+    update_any_client,
+    update_api_client,
+    update_direct_client,
+    update_migration_metadata,
+    update_route,
+)
+from my_app_name._zrb.format_task import format_my_app_name_code
+from my_app_name._zrb.group import app_create_group
+from my_app_name._zrb.input import (
+    existing_module_input,
+    new_entity_column_input,
+    new_entity_input,
+    plural_entity_input,
+)
+from my_app_name._zrb.util import get_existing_module_names, get_existing_schema_names
+
+from zrb import AnyContext, ContentTransformer, Scaffolder, Task, make_task
+from zrb.util.string.conversion import to_snake_case
+
+
+@make_task(
+    name="validate-create-my-app-name-entity",
+    input=[
+        existing_module_input,
+        new_entity_input,
+        plural_entity_input,
+        new_entity_column_input,
+    ],
+    retries=0,
+)
+async def validate_create_my_app_name_entity(ctx: AnyContext):
+    module_name = to_snake_case(ctx.input.module)
+    if module_name not in get_existing_module_names():
+        raise ValueError(f"Module not exist: {module_name}")
+    schema_name = to_snake_case(ctx.input.entity)
+    if schema_name in get_existing_schema_names():
+        raise ValueError(f"Schema already exists: {schema_name}")
+
+
+scaffold_my_app_name_entity = Scaffolder(
+    name="scaffold-my-app-name-entity",
+    input=[
+        existing_module_input,
+        new_entity_input,
+        plural_entity_input,
+        new_entity_column_input,
+    ],
+    source_path=os.path.join(os.path.dirname(__file__), "template", "app_template"),
+    render_source_path=False,
+    destination_path=APP_DIR,
+    transform_path={
+        "my_module": "{to_snake_case(ctx.input.module)}",
+        "my_entity": "{to_snake_case(ctx.input.entity)}",
+    },
+    transform_content=[
+        # Schema tranformation (my_app_name/schema/snake_entity_name)
+        ContentTransformer(
+            match=is_in_app_schema_dir,
+            transform={
+                "MyEntity": "{to_pascal_case(ctx.input.entity)}",
+                "my_column": "{to_snake_case(ctx.input.column)}",
+            },
+        ),
+        # Common module's entity transformation
+        # (my_app_name/module/snake_module_name/service/snake_entity_name)
+        ContentTransformer(
+            match=is_in_module_entity_dir,
+            transform={
+                "my_module": "{to_snake_case(ctx.input.module)}",
+                "MyEntity": "{to_pascal_case(ctx.input.entity)}",
+                "my_entity": "{to_snake_case(ctx.input.entity)}",
+                "my_entities": "{to_snake_case(ctx.input.plural)}",
+                "my-entities": "{to_kebab_case(ctx.input.plural)}",
+            },
+        ),
+        # Add entity to migration metadata
+        # (my_app_name/module/snake_module_name/migration_metadata.py)
+        ContentTransformer(
+            match=is_module_migration_metadata_file,
+            transform=update_migration_metadata,
+        ),
+        # Update API Client (my_app_name/module/snake_module_name/client/api_client.py)
+        ContentTransformer(
+            match=is_module_api_client_file,
+            transform=update_api_client,
+        ),
+        # Update Direct Client (my_app_name/module/snake_module_name/client/direct_client.py)
+        ContentTransformer(
+            match=is_module_direct_client_file,
+            transform=update_direct_client,
+        ),
+        # Update Any Client (my_app_name/module/snake_module_name/client/any_client.py)
+        ContentTransformer(
+            match=is_module_any_client_file,
+            transform=update_any_client,
+        ),
+        # Update module route (my_app_name/module/route.py)
+        ContentTransformer(
+            match=is_module_route_file,
+            transform=update_route,
+        ),
+        # TODO: Register gateway route
+    ],
+    retries=0,
+    upstream=validate_create_my_app_name_entity,
+)
+
+add_my_app_name_entity = app_create_group.add_task(
+    Task(
+        name="add-my-app-name-entity",
+        description="🏗️ Create new entity on a module",
+        upstream=scaffold_my_app_name_entity,
+        successor=format_my_app_name_code,
+        retries=0,
+    ),
+    alias="entity",
+)

zrb-1.0.0a20/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/entity/add_entity_util.py

@@ -0,0 +1,213 @@
+import os
+
+from my_app_name._zrb.config import APP_DIR
+
+from zrb.context.any_context import AnyContext
+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
+
+
+def is_in_app_schema_dir(ctx: AnyContext, file_path: str) -> bool:
+    return file_path.startswith(
+        os.path.join(APP_DIR, "schema", to_snake_case(ctx.input.entity))
+    )
+
+
+def is_in_module_entity_dir(ctx: AnyContext, file_path: str) -> bool:
+    return file_path.startswith(
+        os.path.join(
+            APP_DIR,
+            "module",
+            to_snake_case(ctx.input.module),
+            "service",
+            to_snake_case(ctx.input.entity),
+        )
+    )
+
+
+def is_module_route_file(ctx: AnyContext, file_path: str) -> bool:
+    module_route_file = os.path.join(
+        APP_DIR,
+        "module",
+        to_snake_case(ctx.input.module),
+        "route.py",
+    )
+    return file_path == module_route_file
+
+
+def is_module_migration_metadata_file(ctx: AnyContext, file_path: str) -> bool:
+    module_migration_metadata_file = os.path.join(
+        APP_DIR,
+        "module",
+        to_snake_case(ctx.input.module),
+        "migration_metadata.py",
+    )
+    return file_path == module_migration_metadata_file
+
+
+def is_module_any_client_file(ctx: AnyContext, file_path: str) -> bool:
+    module_any_client_file = os.path.join(
+        APP_DIR,
+        "module",
+        to_snake_case(ctx.input.module),
+        "client",
+        "any_client.py",
+    )
+    return file_path == module_any_client_file
+
+
+def is_module_api_client_file(ctx: AnyContext, file_path: str) -> bool:
+    module_api_client_file = os.path.join(
+        APP_DIR,
+        "module",
+        to_snake_case(ctx.input.module),
+        "client",
+        "api_client.py",
+    )
+    return file_path == module_api_client_file
+
+
+def is_module_direct_client_file(ctx: AnyContext, file_path: str) -> bool:
+    module_direct_client_file = os.path.join(
+        APP_DIR,
+        "module",
+        to_snake_case(ctx.input.module),
+        "client",
+        "direct_client.py",
+    )
+    return file_path == module_direct_client_file
+
+
+def update_migration_metadata(ctx: AnyContext, migration_metadata_file_path: str):
+    app_name = os.path.basename(APP_DIR)
+    existing_migration_metadata_code = read_file(migration_metadata_file_path)
+    write_file(
+        file_path=migration_metadata_file_path,
+        content=[
+            _get_import_schema_code(
+                existing_migration_metadata_code, app_name, ctx.input.entity
+            ),
+            existing_migration_metadata_code.strip(),
+            _get_entity_metadata_assignment_code(
+                existing_migration_metadata_code, ctx.input.entity
+            ),
+        ],
+    )
+
+
+def _get_import_schema_code(
+    existing_code: str, app_name: str, entity_name: str
+) -> str | None:
+    snake_entity_name = to_snake_case(entity_name)
+    pascal_entity_name = to_pascal_case(entity_name)
+    import_module_path = f"{app_name}.schema.{snake_entity_name}"
+    import_schema_code = f"from {import_module_path} import {pascal_entity_name}"
+    if import_schema_code in existing_code:
+        return None
+    return import_schema_code
+
+
+def _get_entity_metadata_assignment_code(
+    existing_code: str, entity_name: str
+) -> str | None:
+    pascal_entity_name = to_pascal_case(entity_name)
+    entity_metadata_assignment_code = "\n".join(
+        [
+            f"{pascal_entity_name}.metadata = metadata",
+            f"{pascal_entity_name}.__table__.tometadata(metadata)",
+        ]
+    )
+    if entity_metadata_assignment_code in existing_code:
+        return None
+    return entity_metadata_assignment_code
+
+
+def update_any_client(ctx: AnyContext, any_client_file_path: str):
+    existing_any_client_code = read_file(any_client_file_path)
+    app_name = os.path.basename(APP_DIR)
+    snake_entity_name = to_snake_case(ctx.input.entity)
+    snake_plural_entity_name = to_snake_case(ctx.input.plural)
+    pascal_entity_name = to_pascal_case(ctx.input.entity)
+    any_client_method = read_file(
+        file_path=os.path.join(
+            os.path.dirname(__file__), "template", "any_client_method.py"
+        ),
+        replace_map={
+            "my_entity": snake_entity_name,
+            "my_entities": snake_plural_entity_name,
+            "MyEntity": pascal_entity_name,
+        },
+    )
+    new_code = append_code_to_class(
+        existing_any_client_code, "AnyClient", any_client_method
+    )
+    write_file(
+        file_path=any_client_file_path,
+        content=[
+            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",  # noqa
+            ")",
+            new_code.strip(),
+        ],
+    )
+
+
+def update_api_client(ctx: AnyContext, api_client_file_path: str):
+    existing_api_client_code = read_file(api_client_file_path)
+    upper_snake_module_name = to_snake_case(ctx.input.module).upper()
+    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(
+        file_path=api_client_file_path,
+        content=[
+            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(
+                    existing_api_client_code, "APIClient", "user_api_client"
+                ),
+                f"user_api_client = user_usecase.as_api_client(base_url=APP_{upper_snake_module_name}_BASE_URL)",  # noqa
+            ),
+        ],
+    )
+
+
+def update_direct_client(ctx: AnyContext, direct_client_file_path: str):
+    existing_direct_client_code = 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(
+        file_path=direct_client_file_path,
+        content=[
+            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(
+                    existing_direct_client_code, "DirectClient", "user_direct_client"
+                ),
+                "user_direct_client = user_usecase.as_direct_client()",
+            ).strip(),
+        ],
+    )
+
+
+def update_route(ctx: AnyContext, route_file_path: str):
+    existing_route_code = read_file(route_file_path)
+    entity_name = to_snake_case(ctx.input.entity)
+    app_name = os.path.basename(APP_DIR)
+    module_name = to_snake_case(ctx.input.module)
+    write_file(
+        file_path=route_file_path,
+        content=[
+            f"from {app_name}.module.{module_name}.service.{entity_name}.{entity_name}_usecase import {entity_name}_usecase",  # noqa
+            append_code_to_function(
+                existing_route_code,
+                "serve_route",
+                f"{entity_name}_usecase.serve_route(app)",
+            ),
+        ],
+    )