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

zrb/builtin/generator/fastapp_crud/add.py

@@ -1,28 +1,32 @@
-from zrb.helper.typing import Any
-from zrb.builtin.generator.fastapp_crud.task_factory import (
-    create_add_navigation_task
+import asyncio
+import os
+
+from zrb.builtin.generator.common.helper import validate_existing_project_dir
+from zrb.builtin.generator.common.task_input import (
+    app_name_input,
+    entity_name_input,
+    main_column_name_input,
+    module_name_input,
+    plural_entity_name_input,
+    project_dir_input,
 )
 from zrb.builtin.generator.fastapp_crud.helper import (
-    register_api, register_permission, register_rpc
-)
-from zrb.builtin.generator.common.task_input import (
-    project_dir_input, app_name_input, module_name_input, entity_name_input,
-    plural_entity_name_input, main_column_name_input
+    register_api,
+    register_permission,
+    register_rpc,
 )
-from zrb.builtin.generator.common.helper import validate_existing_project_dir
+from zrb.builtin.generator.fastapp_crud.task_factory import create_add_navigation_task
 from zrb.builtin.group import project_add_group
-from zrb.task.task import Task
-from zrb.task.decorator import python_task
+from zrb.helper import util
+from zrb.helper.typing import Any
+from zrb.runner import runner
 from zrb.task.cmd_task import CmdTask
+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__)
-CODEMOD_DIR = os.path.join(CURRENT_DIR, 'nodejs', 'codemod')
+CODEMOD_DIR = os.path.join(CURRENT_DIR, "nodejs", "codemod")
 
 ###############################################################################
 # Task Definitions
@@ -30,41 +34,35 @@ CODEMOD_DIR = os.path.join(CURRENT_DIR, 'nodejs', 'codemod')
 
 
 @python_task(
-    name='validate',
-    inputs=[
-        project_dir_input, app_name_input, module_name_input, entity_name_input
-    ],
+    name="validate",
+    inputs=[project_dir_input, app_name_input, module_name_input, entity_name_input],
 )
 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')
-    entity_name = kwargs.get('entity_name')
+    app_name = kwargs.get("app_name")
+    module_name = kwargs.get("module_name")
+    entity_name = kwargs.get("entity_name")
     snake_module_name = util.to_snake_case(module_name)
     snake_entity_name = util.to_snake_case(entity_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 not os.path.exists(module_path):
-        raise Exception(f'Module directory does not exist: {module_path}')
-    entity_path = os.path.join(module_path, 'entity', snake_entity_name)
+        raise Exception(f"Module directory does not exist: {module_path}")
+    entity_path = os.path.join(module_path, "entity", snake_entity_name)
     if os.path.exists(entity_path):
-        raise Exception(f'Entity directory already exists: {entity_path}')
+        raise Exception(f"Entity directory already exists: {entity_path}")
 
 
 copy_resource = ResourceMaker(
-    name='copy-resource',
+    name="copy-resource",
     inputs=[
         project_dir_input,
         app_name_input,
@@ -75,22 +73,22 @@ copy_resource = ResourceMaker(
     ],
     upstreams=[validate],
     replacements={
-        'zrbAppName': '{{input.app_name}}',
-        'zrbModuleName': '{{input.module_name}}',
-        'zrbEntityName': '{{input.entity_name}}',
-        'zrbPluralEntityName': '{{input.plural_entity_name}}',
-        'zrbColumnName': '{{input.column_name}}',
+        "zrbAppName": "{{input.app_name}}",
+        "zrbModuleName": "{{input.module_name}}",
+        "zrbEntityName": "{{input.entity_name}}",
+        "zrbPluralEntityName": "{{input.plural_entity_name}}",
+        "zrbColumnName": "{{input.column_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='register-crud',
+    name="register-crud",
     inputs=[
         project_dir_input,
         app_name_input,
@@ -101,40 +99,40 @@ copy_resource = ResourceMaker(
     ],
     upstreams=[
         copy_resource,
-    ]
+    ],
 )
 async def register_crud(*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')
-    entity_name = kwargs.get('entity_name')
+    task: Task = kwargs.get("_task")
+    project_dir = kwargs.get("project_dir", ".")
+    app_name = kwargs.get("app_name")
+    module_name = kwargs.get("module_name")
+    entity_name = kwargs.get("entity_name")
     kebab_app_name = util.to_kebab_case(app_name)
     snake_module_name = util.to_snake_case(module_name)
     snake_entity_name = util.to_snake_case(entity_name)
     await asyncio.gather(
-        asyncio.create_task(register_api(
-            task, project_dir, kebab_app_name, snake_module_name,
-            snake_entity_name
-        )),
-        asyncio.create_task(register_rpc(
-            task, project_dir, kebab_app_name, snake_module_name,
-            snake_entity_name
-        )),
-        asyncio.create_task(register_permission(
-            task, project_dir, kebab_app_name, snake_module_name,
-            snake_entity_name
-        )),
+        asyncio.create_task(
+            register_api(
+                task, project_dir, kebab_app_name, snake_module_name, snake_entity_name
+            )
+        ),
+        asyncio.create_task(
+            register_rpc(
+                task, project_dir, kebab_app_name, snake_module_name, snake_entity_name
+            )
+        ),
+        asyncio.create_task(
+            register_permission(
+                task, project_dir, kebab_app_name, snake_module_name, snake_entity_name
+            )
+        ),
     )
 
 
 prepare_codemod = CmdTask(
-    name='prepare-codemod',
+    name="prepare-codemod",
     cwd=CODEMOD_DIR,
-    cmd=[
-        'npm install --save-dev',
-        'node_modules/.bin/tsc'
-    ]
+    cmd=["npm install --save-dev", "node_modules/.bin/tsc"],
 )
 
 add_navigation = create_add_navigation_task(
@@ -146,14 +144,11 @@ add_navigation = create_add_navigation_task(
 
 
 @python_task(
-    name='fastapp-crud',
+    name="fastapp-crud",
     group=project_add_group,
-    upstreams=[
-        register_crud,
-        add_navigation
-    ],
-    runner=runner
+    upstreams=[register_crud, add_navigation],
+    runner=runner,
 )
 async def add_fastapp_crud(*args: Any, **kwargs: Any):
-    task: Task = kwargs.get('_task')
-    task.print_out('Success')
+    task: Task = kwargs.get("_task")
+    task.print_out("Success")

zrb/builtin/generator/fastapp_crud/helper.py

@@ -1,9 +1,10 @@
-from zrb.helper.typecheck import typechecked
-from zrb.task.task import Task
+import os
+
 from zrb.helper.codemod.add_import_module import add_import_module
 from zrb.helper.codemod.append_code_to_function import append_code_to_function
 from zrb.helper.file.text import read_text_file_async, write_text_file_async
-import os
+from zrb.helper.typecheck import typechecked
+from zrb.task.task import Task
 
 
 @typechecked
@@ -12,35 +13,34 @@ async def register_api(
     project_dir: str,
     kebab_app_name: str,
     snake_module_name: str,
-    snake_entity_name: str
+    snake_entity_name: str,
 ):
     module_api_file_path = os.path.join(
-        project_dir, 'src', kebab_app_name, 'src', 'module', snake_module_name,
-        'api.py'
+        project_dir, "src", kebab_app_name, "src", "module", snake_module_name, "api.py"
+    )
+    register_function_path = ".".join(
+        ["module", snake_module_name, "entity", snake_entity_name, "api"]
     )
-    register_function_path = '.'.join([
-        'module', snake_module_name, 'entity', snake_entity_name, 'api'
-    ])
-    register_function = f'register_{snake_entity_name}_api'
-    task.print_out(f'Read code from: {module_api_file_path}')
+    register_function = f"register_{snake_entity_name}_api"
+    task.print_out(f"Read code from: {module_api_file_path}")
     code = await read_text_file_async(module_api_file_path)
     task.print_out(
-        f'Add import "register_api" as "{register_function}" ' +
-        f'from "{register_function_path}" to the code'
+        f'Add import "register_api" as "{register_function}" '
+        + f'from "{register_function_path}" to the code'
     )
     code = add_import_module(
         code=code,
         module_path=register_function_path,
-        resource='register_api',
-        alias=register_function
+        resource="register_api",
+        alias=register_function,
     )
     task.print_out(f'Add "{register_function}" call to the code')
     code = append_code_to_function(
         code=code,
-        function_name='register_api',
-        new_code=f'{register_function}(logger, app, authorizer, rpc_caller, publisher)' # noqa
+        function_name="register_api",
+        new_code=f"{register_function}(logger, app, authorizer, rpc_caller, publisher)",  # noqa
     )
-    task.print_out(f'Write modified code to: {module_api_file_path}')
+    task.print_out(f"Write modified code to: {module_api_file_path}")
     await write_text_file_async(module_api_file_path, code)
 
 
@@ -50,35 +50,34 @@ async def register_rpc(
     project_dir: str,
     kebab_app_name: str,
     snake_module_name: str,
-    snake_entity_name: str
+    snake_entity_name: str,
 ):
     module_rpc_file_path = os.path.join(
-        project_dir, 'src', kebab_app_name, 'src', 'module', snake_module_name,
-        'rpc.py'
+        project_dir, "src", kebab_app_name, "src", "module", snake_module_name, "rpc.py"
+    )
+    register_function_path = ".".join(
+        ["module", snake_module_name, "entity", snake_entity_name, "rpc"]
     )
-    register_function_path = '.'.join([
-        'module', snake_module_name, 'entity', snake_entity_name, 'rpc'
-    ])
-    register_function = f'register_{snake_entity_name}_rpc'
-    task.print_out(f'Read code from: {module_rpc_file_path}')
+    register_function = f"register_{snake_entity_name}_rpc"
+    task.print_out(f"Read code from: {module_rpc_file_path}")
     code = await read_text_file_async(module_rpc_file_path)
     task.print_out(
-        f'Add import "register_rpc" as "{register_function}" ' +
-        f'from "{register_function_path}" to the code'
+        f'Add import "register_rpc" as "{register_function}" '
+        + f'from "{register_function_path}" to the code'
     )
     code = add_import_module(
         code=code,
         module_path=register_function_path,
-        resource='register_rpc',
-        alias=register_function
+        resource="register_rpc",
+        alias=register_function,
     )
     task.print_out(f'Add "{register_function}" call to the code')
     code = append_code_to_function(
         code=code,
-        function_name='register_rpc',
-        new_code=f'{register_function}(logger, rpc_server, rpc_caller, publisher)' # noqa
+        function_name="register_rpc",
+        new_code=f"{register_function}(logger, rpc_server, rpc_caller, publisher)",  # noqa
     )
-    task.print_out(f'Write modified code to: {module_rpc_file_path}')
+    task.print_out(f"Write modified code to: {module_rpc_file_path}")
     await write_text_file_async(module_rpc_file_path, code)
 
 
@@ -88,28 +87,32 @@ async def register_permission(
     project_dir: str,
     kebab_app_name: str,
     snake_module_name: str,
-    snake_entity_name: str
+    snake_entity_name: str,
 ):
     module_register_permission_file_path = os.path.join(
-        project_dir, 'src', kebab_app_name, 'src', 'module', 'auth',
-        'register_permission.py'
+        project_dir,
+        "src",
+        kebab_app_name,
+        "src",
+        "module",
+        "auth",
+        "register_permission.py",
     )
-    task.print_out(f'Read code from: {module_register_permission_file_path}')
+    task.print_out(f"Read code from: {module_register_permission_file_path}")
     code = await read_text_file_async(module_register_permission_file_path)
     code = append_code_to_function(
         code=code,
-        function_name='register_permission',
-        new_code='\n'.join([
-            'await ensure_entity_permission(',
-            f"    module_name='{snake_module_name}', entity_name='{snake_entity_name}'", # noqa
-            ')'
-        ])
-    )
-    task.print_out(
-        f'Add "ensure_entity_permission" call for {snake_entity_name} ' +
-        'to the code'
+        function_name="register_permission",
+        new_code="\n".join(
+            [
+                "await ensure_entity_permission(",
+                f"    module_name='{snake_module_name}', entity_name='{snake_entity_name}'",  # noqa
+                ")",
+            ]
+        ),
     )
     task.print_out(
-        f'Write modified code to: {module_register_permission_file_path}'
+        f'Add "ensure_entity_permission" call for {snake_entity_name} ' + "to the code"
     )
+    task.print_out(f"Write modified code to: {module_register_permission_file_path}")
     await write_text_file_async(module_register_permission_file_path, code)

zrb/builtin/generator/fastapp_crud/task_factory.py

@@ -1,27 +1,30 @@
-from zrb.helper.typing import List
+import os
+
+from zrb.builtin.generator.common.task_input import (
+    app_name_input,
+    entity_name_input,
+    module_name_input,
+    project_dir_input,
+)
 from zrb.helper.typecheck import typechecked
+from zrb.helper.typing import List
 from zrb.task.any_task import AnyTask
 from zrb.task.cmd_task import CmdTask
-from zrb.builtin.generator.common.task_input import (
-    project_dir_input, app_name_input, module_name_input, entity_name_input,
-)
-
-import os
 
 CURRENT_DIR = os.path.dirname(__file__)
-CODEMOD_DIR = os.path.join(CURRENT_DIR, 'nodejs', 'codemod')
+CODEMOD_DIR = os.path.join(CURRENT_DIR, "nodejs", "codemod")
 
-NAV_CONFIG_FILE_PATH = '{{input.project_dir}}/src/{{util.to_kebab_case(input.app_name)}}/src/frontend/src/lib/config/navData.ts' # noqa
-ENV_VAR_NAME = 'navData'
-NAV_TITLE = '{{util.to_pascal_case(input.entity_name)}}'
-NAV_URL = '/{{util.to_kebab_case(input.module_name)}}/{{util.to_kebab_case(input.entity_name)}}' # noqa
-NAV_PERMISSION = '{{util.to_snake_case(input.module_name)}}:{{util.to_snake_case(input.entity_name)}}:get' # noqa
+NAV_CONFIG_FILE_PATH = "{{input.project_dir}}/src/{{util.to_kebab_case(input.app_name)}}/src/frontend/src/lib/config/navData.ts"  # noqa
+ENV_VAR_NAME = "navData"
+NAV_TITLE = "{{util.to_pascal_case(input.entity_name)}}"
+NAV_URL = "/{{util.to_kebab_case(input.module_name)}}/{{util.to_kebab_case(input.entity_name)}}"  # noqa
+NAV_PERMISSION = "{{util.to_snake_case(input.module_name)}}:{{util.to_snake_case(input.entity_name)}}:get"  # noqa
 
 
 @typechecked
 def create_add_navigation_task(upstreams: List[AnyTask]) -> AnyTask:
     return CmdTask(
-        name='add-navigation',
+        name="add-navigation",
         inputs=[
             project_dir_input,
             app_name_input,
@@ -30,5 +33,5 @@ def create_add_navigation_task(upstreams: List[AnyTask]) -> AnyTask:
         ],
         upstreams=upstreams,
         retry=0,
-        cmd=f'node {CODEMOD_DIR}/dist/addNav.js "{NAV_CONFIG_FILE_PATH}" "{ENV_VAR_NAME}" "{NAV_TITLE}" "{NAV_URL}" "{NAV_PERMISSION}"' # noqa
+        cmd=f'node {CODEMOD_DIR}/dist/addNav.js "{NAV_CONFIG_FILE_PATH}" "{ENV_VAR_NAME}" "{NAV_TITLE}" "{NAV_URL}" "{NAV_PERMISSION}"',  # noqa
     )

zrb/builtin/generator/fastapp_crud/template/src/kebab-zrb-app-name/src/module/snake_zrb_module_name/component/model/snake_zrb_entity_name_model.py

@@ -1,9 +1,9 @@
 from component.messagebus import publisher
 from module.snake_zrb_module_name.component.repo.snake_zrb_entity_name_repo import (
-    snake_zrb_entity_name_repo
+    snake_zrb_entity_name_repo,
 )
 from module.snake_zrb_module_name.entity.snake_zrb_entity_name.model import (
-    PascalZrbEntityNameModel
+    PascalZrbEntityNameModel,
 )
 
 snake_zrb_entity_name_model: PascalZrbEntityNameModel = PascalZrbEntityNameModel(

zrb/builtin/generator/fastapp_crud/template/src/kebab-zrb-app-name/src/module/snake_zrb_module_name/component/repo/snake_zrb_entity_name_repo.py

@@ -1,7 +1,8 @@
-from component.log import logger
 from component.db_connection import engine
+from component.log import logger
 from module.snake_zrb_module_name.entity.snake_zrb_entity_name.repo import (
-    PascalZrbEntityNameRepo, PascalZrbEntityNameDBRepo
+    PascalZrbEntityNameDBRepo,
+    PascalZrbEntityNameRepo,
 )
 
 snake_zrb_entity_name_repo: PascalZrbEntityNameRepo = PascalZrbEntityNameDBRepo(

zrb/builtin/generator/fastapp_crud/template/src/kebab-zrb-app-name/src/module/snake_zrb_module_name/entity/snake_zrb_entity_name/api.py

@@ -1,14 +1,17 @@
-from fastapi import FastAPI, Depends
 from logging import Logger
+
+from core.error import HTTPAPIException
 from core.messagebus import Publisher
 from core.rpc import Caller
-from core.error import HTTPAPIException
+from fastapi import Depends, FastAPI
+from module.auth.component import access_token_scheme
 from module.auth.core import Authorizer
+from module.auth.schema.token import AccessTokenData
 from module.snake_zrb_module_name.schema.snake_zrb_entity_name import (
-    PascalZrbEntityName, PascalZrbEntityNameData, PascalZrbEntityNameResult
+    PascalZrbEntityName,
+    PascalZrbEntityNameData,
+    PascalZrbEntityNameResult,
 )
-from module.auth.schema.token import AccessTokenData
-from module.auth.component import access_token_scheme
 
 
 def register_api(
@@ -16,109 +19,124 @@ def register_api(
     app: FastAPI,
     authorizer: Authorizer,
     rpc_caller: Caller,
-    publisher: Publisher
+    publisher: Publisher,
 ):
     logger.info('🥪 Register API for "snake_zrb_module_name.snake_zrb_entity_name"')
 
     @app.get(
-        '/api/v1/kebab-zrb-module-name/kebab-zrb-plural-entity-name', response_model=PascalZrbEntityNameResult
+        "/api/v1/kebab-zrb-module-name/kebab-zrb-plural-entity-name",
+        response_model=PascalZrbEntityNameResult,
     )
     async def get_snake_zrb_entity_names(
-        keyword: str = '', limit: int = 100, offset: int = 0,
-        user_token_data: AccessTokenData = Depends(access_token_scheme)
+        keyword: str = "",
+        limit: int = 100,
+        offset: int = 0,
+        user_token_data: AccessTokenData = Depends(access_token_scheme),
     ):
         if not await authorizer.is_having_permission(
-            user_token_data.user_id, 'snake_zrb_module_name:snake_zrb_entity_name:get'
+            user_token_data.user_id, "snake_zrb_module_name:snake_zrb_entity_name:get"
         ):
-            raise HTTPAPIException(403, 'Unauthorized')
+            raise HTTPAPIException(403, "Unauthorized")
         try:
             result_dict = await rpc_caller.call(
-                'snake_zrb_module_name_get_snake_zrb_entity_name',
+                "snake_zrb_module_name_get_snake_zrb_entity_name",
                 keyword=keyword,
                 criterion={},
                 limit=limit,
                 offset=offset,
-                user_token_data=user_token_data.dict()
+                user_token_data=user_token_data.model_dump(),
             )
             return PascalZrbEntityNameResult(**result_dict)
         except Exception as e:
             raise HTTPAPIException(error=e)
 
     @app.get(
-        '/api/v1/kebab-zrb-module-name/kebab-zrb-plural-entity-name/{id}', response_model=PascalZrbEntityName
+        "/api/v1/kebab-zrb-module-name/kebab-zrb-plural-entity-name/{id}",
+        response_model=PascalZrbEntityName,
     )
     async def get_snake_zrb_entity_name_by_id(
-        id: str,
-        user_token_data: AccessTokenData = Depends(access_token_scheme)
+        id: str, user_token_data: AccessTokenData = Depends(access_token_scheme)
     ):
         if not await authorizer.is_having_permission(
-            user_token_data.user_id, 'snake_zrb_module_name:snake_zrb_entity_name:get_by_id'
+            user_token_data.user_id,
+            "snake_zrb_module_name:snake_zrb_entity_name:get_by_id",
         ):
-            raise HTTPAPIException(403, 'Unauthorized')
+            raise HTTPAPIException(403, "Unauthorized")
         try:
             result_dict = await rpc_caller.call(
-                'snake_zrb_module_name_get_snake_zrb_entity_name_by_id',
-                id=id, user_token_data=user_token_data.dict()
+                "snake_zrb_module_name_get_snake_zrb_entity_name_by_id",
+                id=id,
+                user_token_data=user_token_data.model_dump(),
             )
             return PascalZrbEntityName(**result_dict)
         except Exception as e:
             raise HTTPAPIException(error=e)
 
     @app.post(
-        '/api/v1/kebab-zrb-module-name/kebab-zrb-plural-entity-name', response_model=PascalZrbEntityName
+        "/api/v1/kebab-zrb-module-name/kebab-zrb-plural-entity-name",
+        response_model=PascalZrbEntityName,
     )
     async def insert_snake_zrb_entity_name(
         data: PascalZrbEntityNameData,
-        user_token_data: AccessTokenData = Depends(access_token_scheme)
+        user_token_data: AccessTokenData = Depends(access_token_scheme),
     ):
         if not await authorizer.is_having_permission(
-            user_token_data.user_id, 'snake_zrb_module_name:snake_zrb_entity_name:insert'
+            user_token_data.user_id,
+            "snake_zrb_module_name:snake_zrb_entity_name:insert",
         ):
-            raise HTTPAPIException(403, 'Unauthorized')
+            raise HTTPAPIException(403, "Unauthorized")
         try:
             result_dict = await rpc_caller.call(
-                'snake_zrb_module_name_insert_snake_zrb_entity_name',
-                data=data.dict(), user_token_data=user_token_data.dict()
+                "snake_zrb_module_name_insert_snake_zrb_entity_name",
+                data=data.model_dump(),
+                user_token_data=user_token_data.model_dump(),
             )
             return PascalZrbEntityName(**result_dict)
         except Exception as e:
             raise HTTPAPIException(error=e)
 
     @app.put(
-        '/api/v1/kebab-zrb-module-name/kebab-zrb-plural-entity-name/{id}', response_model=PascalZrbEntityName
+        "/api/v1/kebab-zrb-module-name/kebab-zrb-plural-entity-name/{id}",
+        response_model=PascalZrbEntityName,
     )
     async def update_snake_zrb_entity_name(
-        id: str, data: PascalZrbEntityNameData,
-        user_token_data: AccessTokenData = Depends(access_token_scheme)
+        id: str,
+        data: PascalZrbEntityNameData,
+        user_token_data: AccessTokenData = Depends(access_token_scheme),
     ):
         if not await authorizer.is_having_permission(
-            user_token_data.user_id, 'snake_zrb_module_name:snake_zrb_entity_name:update'
+            user_token_data.user_id,
+            "snake_zrb_module_name:snake_zrb_entity_name:update",
         ):
-            raise HTTPAPIException(403, 'Unauthorized')
+            raise HTTPAPIException(403, "Unauthorized")
         try:
             result_dict = await rpc_caller.call(
-                'snake_zrb_module_name_update_snake_zrb_entity_name',
-                id=id, data=data.dict(), user_token_data=user_token_data.dict()
+                "snake_zrb_module_name_update_snake_zrb_entity_name",
+                id=id,
+                data=data.model_dump(),
+                user_token_data=user_token_data.model_dump(),
             )
             return PascalZrbEntityName(**result_dict)
         except Exception as e:
             raise HTTPAPIException(error=e)
 
     @app.delete(
-        '/api/v1/kebab-zrb-module-name/kebab-zrb-plural-entity-name/{id}', response_model=PascalZrbEntityName
+        "/api/v1/kebab-zrb-module-name/kebab-zrb-plural-entity-name/{id}",
+        response_model=PascalZrbEntityName,
     )
     async def delete_snake_zrb_entity_name(
-        id: str,
-        user_token_data: AccessTokenData = Depends(access_token_scheme)
+        id: str, user_token_data: AccessTokenData = Depends(access_token_scheme)
     ):
         if not await authorizer.is_having_permission(
-            user_token_data.user_id, 'snake_zrb_module_name:snake_zrb_entity_name:delete'
+            user_token_data.user_id,
+            "snake_zrb_module_name:snake_zrb_entity_name:delete",
         ):
-            raise HTTPAPIException(403, 'Unauthorized')
+            raise HTTPAPIException(403, "Unauthorized")
         try:
             result_dict = await rpc_caller.call(
-                'snake_zrb_module_name_delete_snake_zrb_entity_name',
-                id=id, user_token_data=user_token_data.dict()
+                "snake_zrb_module_name_delete_snake_zrb_entity_name",
+                id=id,
+                user_token_data=user_token_data.model_dump(),
             )
             return PascalZrbEntityName(**result_dict)
         except Exception as e: