zrb 1.0.0b7__tar.gz → 1.0.0b9__tar.gz

{zrb-1.0.0b7 → zrb-1.0.0b9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zrb
-Version: 1.0.0b7
+Version: 1.0.0b9
 Summary: Your Automation Powerhouse
 Home-page: https://github.com/state-alchemists/zrb
 License: AGPL-3.0-or-later
@@ -23,6 +23,7 @@ Requires-Dist: fastembed (>=0.5.1,<0.6.0)
 Requires-Dist: isort (>=5.13.2,<5.14.0)
 Requires-Dist: libcst (>=1.5.0,<2.0.0)
 Requires-Dist: pdfplumber (>=0.11.4,<0.12.0) ; extra == "rag"
+Requires-Dist: psutil (>=6.1.1,<7.0.0)
 Requires-Dist: pydantic-ai (>=0.0.19,<0.0.20)
 Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
 Requires-Dist: python-jose[cryptography] (>=3.3.0,<4.0.0)

{zrb-1.0.0b7 → zrb-1.0.0b9}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "zrb"
-version = "1.0.0b7"
+version = "1.0.0b9"
 description = "Your Automation Powerhouse"
 authors = ["Go Frendi Gunawan <gofrendiasgard@gmail.com>"]
 license = "AGPL-3.0-or-later"
@@ -52,6 +52,7 @@ python-jose = {extras = ["cryptography"], version = "^3.3.0"}
 ulid-py = "^1.1.0"
 pydantic-ai = "^0.0.19"
 fastembed = "^0.5.1"
+psutil = "^6.1.1"
 
 [tool.poetry.extras]
 # poetry install -E rag

{zrb-1.0.0b7 → zrb-1.0.0b9}/src/zrb/__main__.py

@@ -16,8 +16,11 @@ def serve_cli():
         cli.run(sys.argv[1:])
     except KeyboardInterrupt:
         print(stylize_warning("\nStopped"), file=sys.stderr)
+        sys.exit(1)
     except RuntimeError as e:
         if f"{e}".lower() != "event loop is closed":
             raise e
+        sys.exit(1)
     except NodeNotFoundError as e:
         print(stylize_error(f"{e}"), file=sys.stderr)
+        sys.exit(1)

{zrb-1.0.0b7 → zrb-1.0.0b9}/src/zrb/builtin/git.py

@@ -57,9 +57,9 @@ from zrb.util.git import (
 )
 async def get_git_diff(ctx: AnyContext):
     ctx.print(stylize_faint("Get directory"))
-    repo_dir = await get_repo_dir(log_method=ctx.print)
+    repo_dir = await get_repo_dir(print_method=ctx.print)
     diff = await get_diff(
-        repo_dir, ctx.input.source, ctx.input.current, log_method=ctx.print
+        repo_dir, ctx.input.source, ctx.input.current, print_method=ctx.print
     )
     result = []
     decorated = []
@@ -88,17 +88,17 @@ async def get_git_diff(ctx: AnyContext):
 )
 async def prune_local_branches(ctx: AnyContext):
     ctx.print(stylize_faint("Get directory"))
-    repo_dir = await get_repo_dir(log_method=ctx.print)
+    repo_dir = await get_repo_dir(print_method=ctx.print)
     ctx.print(stylize_faint("Get existing branches"))
-    branches = await get_branches(repo_dir, log_method=ctx.print)
+    branches = await get_branches(repo_dir, print_method=ctx.print)
     ctx.print(stylize_faint("Get current branch"))
-    current_branch = await get_current_branch(repo_dir, log_method=ctx.print)
+    current_branch = await get_current_branch(repo_dir, print_method=ctx.print)
     for branch in branches:
         if branch == current_branch or branch == "main" or branch == "master":
             continue
         ctx.print(stylize_faint(f"Removing local branch: {branch}"))
         try:
-            await delete_branch(repo_dir, branch, log_method=ctx.print)
+            await delete_branch(repo_dir, branch, print_method=ctx.print)
         except Exception as e:
             ctx.log_error(e)
 
@@ -117,11 +117,11 @@ async def prune_local_branches(ctx: AnyContext):
 )
 async def git_commit(ctx: AnyContext):
     ctx.print(stylize_faint("Get directory"))
-    repo_dir = await get_repo_dir(log_method=ctx.print)
+    repo_dir = await get_repo_dir(print_method=ctx.print)
     ctx.print(stylize_faint("Add changes to staging"))
-    await add(repo_dir, log_method=ctx.print)
+    await add(repo_dir, print_method=ctx.print)
     ctx.print(stylize_faint("Commit changes"))
-    await commit(repo_dir, ctx.input.message, log_method=ctx.print)
+    await commit(repo_dir, ctx.input.message, print_method=ctx.print)
 
 
 @make_task(
@@ -139,12 +139,12 @@ async def git_commit(ctx: AnyContext):
 )
 async def git_pull(ctx: AnyContext):
     ctx.print(stylize_faint("Get directory"))
-    repo_dir = await get_repo_dir(log_method=ctx.print)
+    repo_dir = await get_repo_dir(print_method=ctx.print)
     ctx.print(stylize_faint("Get current branch"))
-    current_branch = await get_current_branch(repo_dir, log_method=ctx.print)
+    current_branch = await get_current_branch(repo_dir, print_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)
+    await pull(repo_dir, remote, current_branch, print_method=ctx.print)
 
 
 @make_task(
@@ -161,9 +161,9 @@ async def git_pull(ctx: AnyContext):
     alias="push",
 )
 async def git_push(ctx: AnyContext):
-    repo_dir = await get_repo_dir(log_method=ctx.print)
+    repo_dir = await get_repo_dir(print_method=ctx.print)
     ctx.print(stylize_faint("Get current branch"))
-    current_branch = await get_current_branch(repo_dir, log_method=ctx.print)
+    current_branch = await get_current_branch(repo_dir, print_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)
+    await push(repo_dir, remote, current_branch, print_method=ctx.print)

{zrb-1.0.0b7 → zrb-1.0.0b9}/src/zrb/builtin/git_subtree.py

@@ -35,7 +35,7 @@ from zrb.util.git_subtree import add_subtree, load_config, pull_subtree, push_su
 )
 async def git_add_subtree(ctx: AnyContext):
     ctx.print(stylize_faint("Get directory"))
-    repo_dir = await get_repo_dir(log_method=ctx.print)
+    repo_dir = await get_repo_dir(print_method=ctx.print)
     ctx.print(stylize_faint("Add subtree"))
     await add_subtree(
         repo_dir=repo_dir,
@@ -43,7 +43,7 @@ async def git_add_subtree(ctx: AnyContext):
         repo_url=ctx.input["repo-url"],
         branch=ctx.input["repo-branch"],
         prefix=ctx.input["repo-prefix"],
-        log_method=ctx.print,
+        print_method=ctx.print,
     )
 
 
@@ -56,7 +56,7 @@ async def git_add_subtree(ctx: AnyContext):
 )
 async def git_pull_subtree(ctx: AnyContext):
     ctx.print(stylize_faint("Get directory"))
-    repo_dir = await get_repo_dir(log_method=ctx.print)
+    repo_dir = await get_repo_dir(print_method=ctx.print)
     config = load_config(repo_dir)
     if not config.data:
         raise ValueError("No subtree config found")
@@ -69,7 +69,7 @@ async def git_pull_subtree(ctx: AnyContext):
                 prefix=detail.prefix,
                 repo_url=detail.repo_url,
                 branch=detail.branch,
-                log_method=ctx.print,
+                print_method=ctx.print,
             )
         except Exception as e:
             if first_err is None:
@@ -88,7 +88,7 @@ async def git_pull_subtree(ctx: AnyContext):
 )
 async def git_push_subtree(ctx: AnyContext):
     ctx.print(stylize_faint("Get directory"))
-    repo_dir = await get_repo_dir(log_method=ctx.print)
+    repo_dir = await get_repo_dir(print_method=ctx.print)
     config = load_config(repo_dir)
     if not config.data:
         raise ValueError("No subtree config found")
@@ -101,7 +101,7 @@ async def git_push_subtree(ctx: AnyContext):
                 prefix=detail.prefix,
                 repo_url=detail.repo_url,
                 branch=detail.branch,
-                log_method=ctx.print,
+                print_method=ctx.print,
             )
         except Exception as e:
             if first_err is None:

{zrb-1.0.0b7 → zrb-1.0.0b9}/src/zrb/builtin/project/add/fastapp/fastapp_task.py

@@ -57,6 +57,7 @@ scaffold_fastapp = Scaffolder(
                 "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(),
+                "my-secret-key": lambda _: get_random_name(),
             },
         ),
         # Register fastapp's tasks to project's zrb_init (project_dir/zrb_init.py)

{zrb-1.0.0b7 → zrb-1.0.0b9}/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/entity/add_entity_task.py

@@ -88,6 +88,7 @@ scaffold_my_app_name_entity = Scaffolder(
             match=is_in_app_schema_dir,
             transform={
                 "MyEntity": "{to_pascal_case(ctx.input.entity)}",
+                "my_entities": "{to_snake_case(ctx.input.plural)}",
                 "my_column": "{to_snake_case(ctx.input.column)}",
             },
         ),

{zrb-1.0.0b7 → zrb-1.0.0b9}/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/entity/template/app_template/module/my_module/service/my_entity/my_entity_service.py

@@ -67,11 +67,11 @@ class MyEntityService(BaseService):
     @BaseService.route(
         "/api/v1/my-entities/bulk",
         methods=["put"],
-        response_model=MyEntityResponse,
+        response_model=list[MyEntityResponse],
     )
     async def update_my_entity_bulk(
         self, my_entity_ids: list[str], data: MyEntityUpdateWithAudit
-    ) -> MyEntityResponse:
+    ) -> list[MyEntityResponse]:
         await self.my_entity_repository.update_bulk(my_entity_ids, data)
         return await self.my_entity_repository.get_by_ids(my_entity_ids)
 
@@ -89,11 +89,11 @@ class MyEntityService(BaseService):
     @BaseService.route(
         "/api/v1/my-entities/bulk",
         methods=["delete"],
-        response_model=MyEntityResponse,
+        response_model=list[MyEntityResponse],
     )
     async def delete_my_entity_bulk(
         self, my_entity_ids: list[str], deleted_by: str
-    ) -> MyEntityResponse:
+    ) -> list[MyEntityResponse]:
         my_entities = await self.my_entity_repository.get_by_ids(my_entity_ids)
         await self.my_entity_repository.delete_bulk(my_entity_ids)
         return my_entities
@@ -106,6 +106,6 @@ class MyEntityService(BaseService):
     async def delete_my_entity(
         self, my_entity_id: str, deleted_by: str
     ) -> MyEntityResponse:
-        my_entity = await self.my_entity_repository.get_by_id(my_entity.id)
+        my_entity = await self.my_entity_repository.get_by_id(my_entity_id)
         await self.my_entity_repository.delete(my_entity_id)
         return my_entity

{zrb-1.0.0b7 → zrb-1.0.0b9}/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/entity/template/app_template/schema/my_entity.py

@@ -39,6 +39,7 @@ class MultipleMyEntityResponse(BaseModel):
 
 
 class MyEntity(SQLModel, table=True):
+    __tablename__ = "my_entities"
     id: str = Field(default_factory=lambda: ulid.new().str, primary_key=True)
     created_at: datetime.datetime = Field(index=True)
     created_by: str = Field(index=True)

{zrb-1.0.0b7 → zrb-1.0.0b9}/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/input.py

@@ -3,6 +3,14 @@ from my_app_name._zrb.util import get_existing_module_names, get_existing_schema
 from zrb import OptionInput, StrInput
 from zrb.util.string.conversion import pluralize
 
+run_env_input = OptionInput(
+    name="env",
+    description="Running environment",
+    prompt="Running Environment",
+    options=["dev", "prod"],
+    default_str="prod",
+)
+
 new_module_input = StrInput(
     name="module", description="Module name", prompt="New module name"
 )

{zrb-1.0.0b7 → zrb-1.0.0b9}/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/task.py

@@ -9,8 +9,14 @@ from my_app_name._zrb.group import (
     app_migrate_group,
     app_run_group,
 )
+from my_app_name._zrb.input import run_env_input
 from my_app_name._zrb.module.add_module_task import add_my_app_name_module
-from my_app_name._zrb.util import create_migration, migrate_module, run_microservice
+from my_app_name._zrb.task_util import (
+    create_migration,
+    migrate_module,
+    run_microservice,
+    run_my_app_name,
+)
 from my_app_name._zrb.venv_task import prepare_venv
 
 from zrb import CmdTask, EnvFile, EnvMap, Task
@@ -52,6 +58,7 @@ run_monolith = app_run_group.add_task(
     CmdTask(
         name="run-monolith-my-app-name",
         description="🗿 Run My App Name as a monolith",
+        input=run_env_input,
         env=[
             EnvFile(path=os.path.join(APP_DIR, "template.env")),
             EnvMap(vars=MONOLITH_ENV_VARS),
@@ -59,7 +66,7 @@ run_monolith = app_run_group.add_task(
         cwd=APP_DIR,
         cmd=[
             ACTIVATE_VENV_SCRIPT,
-            'fastapi dev main.py --port "${MY_APP_NAME_PORT}"',
+            run_my_app_name,
         ],
         render_cmd=False,
         retries=2,

zrb-1.0.0b7/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/util.py → zrb-1.0.0b9/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/task_util.py

@@ -1,5 +1,4 @@
 import os
-import platform
 
 from my_app_name._zrb.config import (
     ACTIVATE_VENV_SCRIPT,
@@ -7,9 +6,17 @@ from my_app_name._zrb.config import (
     MICROSERVICES_ENV_VARS,
     MONOLITH_ENV_VARS,
 )
+from my_app_name._zrb.input import run_env_input
+from my_app_name._zrb.util import (
+    cd_module_script,
+    run_my_app_name,
+    set_create_migration_db_url_env,
+    set_env,
+    set_module_env,
+)
 
 from zrb import Cmd, CmdTask, EnvFile, EnvMap, StrInput, Task
-from zrb.util.string.conversion import double_quote, to_snake_case
+from zrb.util.string.conversion import to_snake_case
 
 
 def create_migration(name: str, module: str) -> Task:
@@ -72,6 +79,7 @@ def run_microservice(name: str, port: int, module: str) -> Task:
     return CmdTask(
         name=f"run-my-app-name-{name}",
         description=f"🧩 Run My App Name {name.capitalize()}",
+        input=run_env_input,
         env=[
             EnvFile(path=os.path.join(APP_DIR, "template.env")),
             EnvMap(
@@ -85,54 +93,8 @@ def run_microservice(name: str, port: int, module: str) -> Task:
             ACTIVATE_VENV_SCRIPT,
             set_env("MY_APP_NAME_MODULES", module),
             set_env("MY_APP_NAME_PORT", f"{port}"),
-            'fastapi dev main.py --port "${MY_APP_NAME_PORT}"',
+            run_my_app_name,
         ],
         render_cmd=False,
         retries=2,
     )
-
-
-def get_existing_module_names() -> list[str]:
-    module_dir_path = os.path.join(APP_DIR, "module")
-    return [entry.name for entry in os.scandir(module_dir_path) if entry.is_dir()]
-
-
-def get_existing_schema_names() -> list[str]:
-    module_dir_path = os.path.join(APP_DIR, "schema")
-    return [
-        os.path.splitext(entry.name)[0]
-        for entry in os.scandir(module_dir_path)
-        if entry.is_file() and entry.name.endswith(".py")
-    ]
-
-
-def set_create_migration_db_url_env(module_name: str) -> str:
-    return set_env(
-        "MY_APP_NAME_DB_URL",
-        f"sqlite:///{APP_DIR}/.migration.{to_snake_case(module_name)}.db",
-    )
-
-
-def set_module_env(module_name: str) -> str:
-    return (set_env("MY_APP_NAME_MODULES", to_snake_case(module_name)),)
-
-
-def cd_module_script(module_name: str) -> str:
-    module_dir_path = os.path.join(APP_DIR, "module", to_snake_case(module_name))
-    return f"cd {module_dir_path}"
-
-
-def set_env(var_name: str, var_value: str) -> str:
-    """
-    Generates a script to set an environment variable depending on the OS.
-    :param var_name: Name of the environment variable.
-    :param var_value: Value of the environment variable.
-    :return: A string containing the appropriate script.
-    """
-    if platform.system() == "Windows":
-        # PowerShell script for Windows
-        script = f'[Environment]::SetEnvironmentVariable({double_quote(var_name)}, {double_quote(var_value)}, "User")'  # noqa
-    else:
-        # Bash script for Unix-like systems
-        script = f"export {var_name}={double_quote(var_value)}"
-    return script

zrb-1.0.0b9/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/util.py

@@ -0,0 +1,58 @@
+import os
+import platform
+
+from my_app_name._zrb.config import APP_DIR
+
+from zrb import AnyContext
+from zrb.util.string.conversion import double_quote, to_snake_case
+
+
+def run_my_app_name(ctx: AnyContext) -> str:
+    subcommand = "dev" if ctx.input.env == "dev" else "run"
+    return f'fastapi {subcommand}  main.py --port "${{MY_APP_NAME_PORT}}"'
+
+
+def get_existing_module_names() -> list[str]:
+    module_dir_path = os.path.join(APP_DIR, "module")
+    return [entry.name for entry in os.scandir(module_dir_path) if entry.is_dir()]
+
+
+def get_existing_schema_names() -> list[str]:
+    module_dir_path = os.path.join(APP_DIR, "schema")
+    return [
+        os.path.splitext(entry.name)[0]
+        for entry in os.scandir(module_dir_path)
+        if entry.is_file() and entry.name.endswith(".py")
+    ]
+
+
+def set_create_migration_db_url_env(module_name: str) -> str:
+    return set_env(
+        "MY_APP_NAME_DB_URL",
+        f"sqlite:///{APP_DIR}/.migration.{to_snake_case(module_name)}.db",
+    )
+
+
+def set_module_env(module_name: str) -> str:
+    return (set_env("MY_APP_NAME_MODULES", to_snake_case(module_name)),)
+
+
+def cd_module_script(module_name: str) -> str:
+    module_dir_path = os.path.join(APP_DIR, "module", to_snake_case(module_name))
+    return f"cd {module_dir_path}"
+
+
+def set_env(var_name: str, var_value: str) -> str:
+    """
+    Generates a script to set an environment variable depending on the OS.
+    :param var_name: Name of the environment variable.
+    :param var_value: Value of the environment variable.
+    :return: A string containing the appropriate script.
+    """
+    if platform.system() == "Windows":
+        # PowerShell script for Windows
+        script = f'[Environment]::SetEnvironmentVariable({double_quote(var_name)}, {double_quote(var_value)}, "User")'  # noqa
+    else:
+        # Bash script for Unix-like systems
+        script = f"export {var_name}={double_quote(var_value)}"
+    return script

{zrb-1.0.0b7 → zrb-1.0.0b9}/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/common/base_db_repository.py

@@ -122,9 +122,19 @@ class BaseDBRepository(Generic[DBModel, ResponseModel, CreateModel, UpdateModel]
         return self._ensure_one(rows)
 
     async def get_by_ids(self, id_list: list[str]) -> list[ResponseModel]:
-        return await self._select_to_response(
+        rows = await self._select_to_response(
             lambda q: q.where(self.db_model.id.in_(id_list))
         )
+        # raise error if any id not in id_list
+        existing_id_list = [row.id for row in rows]
+        inexist_id_list = [id for id in id_list if id not in existing_id_list]
+        if len(inexist_id_list) > 0:
+            raise NotFoundError(
+                f"{self.entity_name} not found, inexist ids: {', '.join(inexist_id_list)}"
+            )
+        # sort rows
+        row_dict = {row.id: row for row in rows}
+        return [row_dict[id] for id in id_list]
 
     async def count(self, filter: str | None = None) -> int:
         count_statement = select(func.count(1)).select_from(self.db_model)
@@ -184,21 +194,22 @@ class BaseDBRepository(Generic[DBModel, ResponseModel, CreateModel, UpdateModel]
 
     async def create_bulk(self, data_list: list[CreateModel]) -> list[DBModel]:
         now = datetime.datetime.now(datetime.timezone.utc)
-        data_dicts = [
+        data_dict_list = [
             self._model_to_data_dict(data, created_at=now, id=ulid.new().str)
             for data in data_list
         ]
+        id_list = [data_dict["id"] for data_dict in data_dict_list]
         async with self._session_scope() as session:
             await self._execute_statement(
-                session, insert(self.db_model).values(data_dicts)
+                session, insert(self.db_model).values(data_dict_list)
             )
-            id_list = [d["id"] for d in data_dicts]
             statement = select(self.db_model).where(self.db_model.id.in_(id_list))
             result = await self._execute_statement(session, statement)
-            return [
-                self.db_model(**entity.model_dump())
+            row_dict = {
+                entity.id: self.db_model(**entity.model_dump())
                 for entity in result.scalars().all()
-            ]
+            }
+            return [row_dict[id] for id in id_list]
 
     async def delete(self, id: str) -> DBModel:
         async with self._session_scope() as session:
@@ -220,11 +231,15 @@ class BaseDBRepository(Generic[DBModel, ResponseModel, CreateModel, UpdateModel]
             await self._execute_statement(
                 session, delete(self.db_model).where(self.db_model.id.in_(id_list))
             )
-            return [self.db_model(**entity.model_dump()) for entity in entities]
+            row_dict = {
+                entity.id: self.db_model(**entity.model_dump()) for entity in entities
+            }
+            return [row_dict[id] for id in id_list]
 
     async def update(self, id: str, data: UpdateModel) -> DBModel:
         now = datetime.datetime.now(datetime.timezone.utc)
         update_data = self._model_to_data_dict(data, updated_at=now)
+        update_data = {k: v for k, v in update_data.items() if v is not None}
         async with self._session_scope() as session:
             statement = (
                 update(self.db_model)
@@ -256,7 +271,8 @@ class BaseDBRepository(Generic[DBModel, ResponseModel, CreateModel, UpdateModel]
             result = await self._execute_statement(
                 session, select(self.db_model).where(self.db_model.id.in_(id_list))
             )
-            return [
-                self.db_model(**entity.model_dump())
+            row_dict = {
+                entity.id: self.db_model(**entity.model_dump())
                 for entity in result.scalars().all()
-            ]
+            }
+            return [row_dict[id] for id in id_list]

{zrb-1.0.0b7 → zrb-1.0.0b9}/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/common/base_service.py

@@ -56,7 +56,6 @@ class BaseService:
         response_model: Any = None,
         status_code: int | None = None,
         tags: list[str | Enum] | None = None,
-        dependencies: Sequence[params.Depends] | None = None,
         summary: str | None = None,
         description: str = None,
         deprecated: bool | None = None,
@@ -160,56 +159,62 @@ def _create_direct_client_method(logger: Logger, func: Callable, service: BaseSe
     return client_method
 
 
-def _create_api_client_method(logger: Logger, param: RouteParam, base_url: str):
+def _create_api_client_method(logger: Logger, route_param: RouteParam, base_url: str):
     async def client_method(*args, **kwargs):
-        url = base_url + param.path
+        url = base_url + route_param.path
         method = (
-            param.methods[0].lower()
-            if isinstance(param.methods, list)
-            else param.methods.lower()
+            route_param.methods[0].lower()
+            if isinstance(route_param.methods, list)
+            else route_param.methods.lower()
         )
         # Get the signature of the original function
-        sig = inspect.signature(param.func)
+        sig = inspect.signature(route_param.func)
         # Bind the arguments to the signature
         bound_args = sig.bind(*args, **kwargs)
         bound_args.apply_defaults()
         # Analyze parameters
-        params = list(sig.parameters.values())
-        body_params = [
-            p
-            for p in params
-            if p.name != "self" and p.kind == inspect.Parameter.POSITIONAL_OR_KEYWORD
+        function_params = list(sig.parameters.values())
+        body_param_names = [
+            p.name
+            for p in function_params
+            if (
+                p.name != "self"
+                and f"{{{p.name}}}" not in route_param.path
+                and p.kind == inspect.Parameter.POSITIONAL_OR_KEYWORD
+                and (
+                    method not in ["get", "delete"]
+                    or (method == "delete" and p.annotation not in [str, float, bool])
+                )
+            )
         ]
         # Prepare the request
         path_params = {}
         query_params = {}
-        body = {}
+        body_params = {}
         for name, value in bound_args.arguments.items():
             if name == "self":
                 continue
-            if f"{{{name}}}" in param.path:
+            if f"{{{name}}}" in route_param.path:
                 path_params[name] = value
-            elif isinstance(value, BaseModel):
-                body = _parse_api_param(value)
-            elif method in ["get", "delete"]:
+            elif name not in body_param_names:
                 query_params[name] = _parse_api_param(value)
-            elif len(body_params) == 1 and name == body_params[0].name:
+            elif len(body_param_names) == 1 and name == body_param_names[0]:
                 # If there's only one body parameter, use its value directly
-                body = _parse_api_param(value)
+                body_params = _parse_api_param(value)
             else:
-                body[name] = _parse_api_param(value)
+                body_params[name] = _parse_api_param(value)
         # Format the URL with path parameters
         url = url.format(**path_params)
         logger.info(
-            f"Sending request to {url} with method {method}, json={body}, params={query_params}"  # noqa
+            f"Sending request to {url} with method {method}, json={body_params}, params={query_params}"  # noqa
         )
         async with httpx.AsyncClient() as client:
-            if method in ["get", "delete"]:
-                response = await getattr(client, method)(url, params=query_params)
-            else:
-                response = await getattr(client, method)(
-                    url, json=body, params=query_params
-                )
+            response = await client.request(
+                method=method,
+                url=url,
+                params=query_params,
+                json=None if method == "get" else body_params,
+            )
             logger.info(
                 f"Received response: status={response.status_code}, content={response.content}"
             )

{zrb-1.0.0b7 → zrb-1.0.0b9}/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/common/error.py

@@ -8,11 +8,26 @@ class NotFoundError(HTTPException):
         super().__init__(404, {"message": message}, headers)
 
 
+class ForbiddenError(HTTPException):
+    def __init__(self, message: str, headers: Dict[str, str] | None = None) -> None:
+        super().__init__(403, {"message": message}, headers)
+
+
+class UnauthorizedError(HTTPException):
+    def __init__(self, message: str, headers: Dict[str, str] | None = None) -> None:
+        super().__init__(401, {"message": message}, headers)
+
+
 class InvalidValueError(HTTPException):
     def __init__(self, message: str, headers: Dict[str, str] | None = None) -> None:
         super().__init__(422, {"message": message}, headers)
 
 
+class InternalServerError(HTTPException):
+    def __init__(self, message: str, headers: Dict[str, str] | None = None) -> None:
+        super().__init__(500, {"message": message}, headers)
+
+
 class ClientAPIError(HTTPException):
     def __init__(
         self, status_code: int, message: str, headers: Dict[str, str] | None = None