zrb 1.0.0a21__py3-none-any.whl → 1.0.0b2__py3-none-any.whl

zrb/__init__.py

@@ -34,7 +34,8 @@ 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.runner.web_config.config_factory import web_config
+from zrb.runner.web_schema.user import User
 from zrb.session.session import Session
 from zrb.task.any_task import AnyTask
 from zrb.task.base_task import BaseTask

zrb/__main__.py

@@ -14,9 +14,6 @@ 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

@@ -12,6 +12,7 @@ from zrb.builtin.md5 import hash_md5, sum_md5
 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.random import shuffle_values, throw_dice
 from zrb.builtin.setup.asdf.asdf import setup_asdf
 from zrb.builtin.setup.latex.ubuntu import setup_latex_on_ubuntu
 from zrb.builtin.setup.tmux.tmux import setup_tmux
@@ -55,6 +56,8 @@ assert edit_todo
 assert complete_todo
 assert log_todo
 assert show_todo
+assert throw_dice
+assert shuffle_values
 assert setup_ubuntu
 assert setup_latex_on_ubuntu
 assert setup_asdf

zrb/builtin/group.py

@@ -2,6 +2,7 @@ from zrb.group.group import Group
 from zrb.runner.cli import cli
 
 base64_group = cli.add_group(Group(name="base64", description="📄 Base64 operations"))
+random_group = cli.add_group(Group(name="random", description="🔀 Random operation"))
 git_group = cli.add_group(Group(name="git", description="🌱 Git related commands"))
 git_branch_group = git_group.add_group(
     Group(name="branch", description="🌿 Git branch related commands")

zrb/builtin/llm/llm_chat.py

@@ -1,6 +1,6 @@
 from zrb.builtin.group import llm_group
 from zrb.builtin.llm.tool.cli import run_shell_command
-from zrb.builtin.llm.tool.web import open_web_page, query_internet
+from zrb.builtin.llm.tool.web import open_web_route, query_internet
 from zrb.config import (
     LLM_ALLOW_ACCESS_SHELL,
     LLM_ALLOW_ACCESS_WEB,
@@ -43,5 +43,5 @@ if LLM_ALLOW_ACCESS_SHELL:
     llm_chat.add_tool(run_shell_command)
 
 if LLM_ALLOW_ACCESS_WEB:
-    llm_chat.add_tool(open_web_page)
+    llm_chat.add_tool(open_web_route)
     llm_chat.add_tool(query_internet)

zrb/builtin/llm/tool/web.py

@@ -2,7 +2,7 @@ import json
 from typing import Annotated
 
 
-def open_web_page(url: str) -> str:
+def open_web_route(url: str) -> str:
     """Get content from a web page."""
     import requests
 

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

@@ -49,6 +49,7 @@ scaffold_fastapp = Scaffolder(
     transform_content=[
         # Common transformation (project_dir/app_dir/**/*)
         ContentTransformer(
+            name="transform-app-dir",
             match=is_in_project_app_dir,
             transform={
                 "My App Name": "{ctx.input.app.title()}",
@@ -60,6 +61,7 @@ scaffold_fastapp = Scaffolder(
         ),
         # Register fastapp's tasks to project's zrb_init (project_dir/zrb_init.py)
         ContentTransformer(
+            name="trasnform-zrb-init",
             match=is_project_zrb_init_file,
             transform=update_project_zrb_init_file,
         ),

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/config.py

@@ -9,9 +9,12 @@ MICROSERVICES_ENV_VARS = {
     "MY_APP_NAME_MODE": "microservices",
     "MY_APP_NAME_AUTH_BASE_URL": "http://localhost:3002",
 }
-MONOLITH_ENV_VARS = {"MY_APP_NAME_MODE": "monolith"}
+MONOLITH_ENV_VARS = {
+    "MY_APP_NAME_MODE": "monolith",
+    "MY_APP_NAME_MODULES": "",
+}
 
 if platform.system() == "Windows":
     ACTIVATE_VENV_SCRIPT = "Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser; . .venv\\Scripts\\Activate"  # noqa
 else:
-    ACTIVATE_VENV_SCRIPT = "source .venv/bin/activate"
+    ACTIVATE_VENV_SCRIPT = ". .venv/bin/activate"

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/entity/add_entity_task.py

@@ -1,19 +1,21 @@
 import os
 
-from my_app_name._zrb.config import APP_DIR
+from my_app_name._zrb.config import ACTIVATE_VENV_SCRIPT, 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_client_file,
     is_module_direct_client_file,
+    is_module_gateway_subroute_file,
     is_module_migration_metadata_file,
     is_module_route_file,
-    update_any_client,
-    update_api_client,
-    update_direct_client,
-    update_migration_metadata,
-    update_route,
+    update_api_client_file,
+    update_client_file,
+    update_direct_client_file,
+    update_gateway_subroute_file,
+    update_migration_metadata_file,
+    update_route_file,
 )
 from my_app_name._zrb.format_task import format_my_app_name_code
 from my_app_name._zrb.group import app_create_group
@@ -23,9 +25,25 @@ from my_app_name._zrb.input import (
     new_entity_input,
     plural_entity_input,
 )
-from my_app_name._zrb.util import get_existing_module_names, get_existing_schema_names
+from my_app_name._zrb.util import (
+    cd_module_script,
+    get_existing_module_names,
+    get_existing_schema_names,
+    set_create_migration_db_url_env,
+    set_env,
+)
+from my_app_name._zrb.venv_task import prepare_venv
 
-from zrb import AnyContext, ContentTransformer, Scaffolder, Task, make_task
+from zrb import (
+    AnyContext,
+    Cmd,
+    CmdTask,
+    ContentTransformer,
+    EnvFile,
+    Scaffolder,
+    Task,
+    make_task,
+)
 from zrb.util.string.conversion import to_snake_case
 
 
@@ -66,6 +84,7 @@ scaffold_my_app_name_entity = Scaffolder(
     transform_content=[
         # Schema tranformation (my_app_name/schema/snake_entity_name)
         ContentTransformer(
+            name="transform-schema-file",
             match=is_in_app_schema_dir,
             transform={
                 "MyEntity": "{to_pascal_case(ctx.input.entity)}",
@@ -75,6 +94,7 @@ scaffold_my_app_name_entity = Scaffolder(
         # Common module's entity transformation
         # (my_app_name/module/snake_module_name/service/snake_entity_name)
         ContentTransformer(
+            name="transform-module-entity-dir",
             match=is_in_module_entity_dir,
             transform={
                 "my_module": "{to_snake_case(ctx.input.module)}",
@@ -87,40 +107,80 @@ scaffold_my_app_name_entity = Scaffolder(
         # Add entity to migration metadata
         # (my_app_name/module/snake_module_name/migration_metadata.py)
         ContentTransformer(
+            name="transform-module-migration-metadata",
             match=is_module_migration_metadata_file,
-            transform=update_migration_metadata,
+            transform=update_migration_metadata_file,
         ),
-        # Update API Client (my_app_name/module/snake_module_name/client/api_client.py)
+        # Update API Client
+        # (my_app_name/module/snake_module_name/client/snake_module_name_api_client.py)
         ContentTransformer(
+            name="transform-module-api-client",
             match=is_module_api_client_file,
-            transform=update_api_client,
+            transform=update_api_client_file,
         ),
-        # Update Direct Client (my_app_name/module/snake_module_name/client/direct_client.py)
+        # Update Direct Client
+        # (my_app_name/module/snake_module_name/client/snake_module_name_direct_client.py)
         ContentTransformer(
+            name="transform-module-direct-client",
             match=is_module_direct_client_file,
-            transform=update_direct_client,
+            transform=update_direct_client_file,
         ),
-        # Update Any Client (my_app_name/module/snake_module_name/client/any_client.py)
+        # Update Client
+        # (my_app_name/module/snake_module_name/client/snake_module_name_client.py)
         ContentTransformer(
-            match=is_module_any_client_file,
-            transform=update_any_client,
+            name="transform-module-any-client",
+            match=is_module_client_file,
+            transform=update_client_file,
         ),
         # Update module route (my_app_name/module/route.py)
         ContentTransformer(
+            name="transform-module-route",
             match=is_module_route_file,
-            transform=update_route,
+            transform=update_route_file,
+        ),
+        # Update module gateway subroute
+        # (my_app_name/module/gateway/subroute/snake_module_name.py)
+        ContentTransformer(
+            name="transform-module-gateway-subroute",
+            match=is_module_gateway_subroute_file,
+            transform=update_gateway_subroute_file,
         ),
-        # TODO: Register gateway route
     ],
     retries=0,
     upstream=validate_create_my_app_name_entity,
 )
 
+create_my_app_name_entity_migration = CmdTask(
+    name="create-my-app-name-entity-migration",
+    input=[
+        existing_module_input,
+        new_entity_input,
+    ],
+    env=EnvFile(path=os.path.join(APP_DIR, "template.env")),
+    cwd=APP_DIR,
+    cmd=[
+        ACTIVATE_VENV_SCRIPT,
+        Cmd(lambda ctx: set_create_migration_db_url_env(ctx.input.module)),
+        Cmd(lambda ctx: set_env("MY_APP_NAME_MODULES", ctx.input.module)),
+        Cmd(lambda ctx: cd_module_script(ctx.input.module)),
+        "alembic upgrade head",
+        Cmd(
+            'alembic revision --autogenerate -m "create_{to_snake_case(ctx.input.entity)}_table"',  # noqa
+        ),
+    ],
+    render_cmd=False,
+    retries=0,
+    upstream=[
+        prepare_venv,
+        scaffold_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,
+        upstream=create_my_app_name_entity_migration,
         successor=format_my_app_name_code,
         retries=0,
     ),

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/entity/add_entity_util.py

@@ -8,7 +8,7 @@ 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
+from zrb.util.string.conversion import to_kebab_case, to_pascal_case, to_snake_case
 
 
 def is_in_app_schema_dir(ctx: AnyContext, file_path: str) -> bool:
@@ -49,13 +49,13 @@ def is_module_migration_metadata_file(ctx: AnyContext, file_path: str) -> bool:
     return file_path == module_migration_metadata_file
 
 
-def is_module_any_client_file(ctx: AnyContext, file_path: str) -> bool:
+def is_module_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",
+        f"{to_snake_case(ctx.input.module)}_client.py",
     )
     return file_path == module_any_client_file
 
@@ -66,7 +66,7 @@ def is_module_api_client_file(ctx: AnyContext, file_path: str) -> bool:
         "module",
         to_snake_case(ctx.input.module),
         "client",
-        "api_client.py",
+        f"{to_snake_case(ctx.input.module)}_api_client.py",
     )
     return file_path == module_api_client_file
 
@@ -77,29 +77,40 @@ def is_module_direct_client_file(ctx: AnyContext, file_path: str) -> bool:
         "module",
         to_snake_case(ctx.input.module),
         "client",
-        "direct_client.py",
+        f"{to_snake_case(ctx.input.module)}_direct_client.py",
     )
     return file_path == module_direct_client_file
 
 
-def update_migration_metadata(ctx: AnyContext, migration_metadata_file_path: str):
+def is_module_gateway_subroute_file(ctx: AnyContext, file_path: str) -> bool:
+    module_gateway_subroute_file = os.path.join(
+        APP_DIR,
+        "module",
+        "gateway",
+        "subroute",
+        f"{to_snake_case(ctx.input.module)}.py",
+    )
+    return file_path == module_gateway_subroute_file
+
+
+def update_migration_metadata_file(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(
+            _get_migration_import_schema_code(
                 existing_migration_metadata_code, app_name, ctx.input.entity
             ),
             existing_migration_metadata_code.strip(),
-            _get_entity_metadata_assignment_code(
+            _get_migration_entity_metadata_assignment_code(
                 existing_migration_metadata_code, ctx.input.entity
             ),
         ],
     )
 
 
-def _get_import_schema_code(
+def _get_migration_import_schema_code(
     existing_code: str, app_name: str, entity_name: str
 ) -> str | None:
     snake_entity_name = to_snake_case(entity_name)
@@ -111,7 +122,7 @@ def _get_import_schema_code(
     return import_schema_code
 
 
-def _get_entity_metadata_assignment_code(
+def _get_migration_entity_metadata_assignment_code(
     existing_code: str, entity_name: str
 ) -> str | None:
     pascal_entity_name = to_pascal_case(entity_name)
@@ -126,76 +137,105 @@ def _get_entity_metadata_assignment_code(
     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)
+def update_client_file(ctx: AnyContext, client_file_path: str):
+    existing_client_code = read_file(client_file_path)
+    pascal_module_name = to_pascal_case(ctx.input.module)
     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,
+        file_path=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(),
+            _get_import_schema_for_client_code(
+                existing_code=existing_client_code, entity_name=ctx.input.entity
+            ),
+            append_code_to_class(
+                original_code=existing_client_code,
+                class_name=f"{pascal_module_name}Client",
+                new_code=read_file(
+                    file_path=os.path.join(
+                        os.path.dirname(__file__), "template", "client_method.py"
+                    ),
+                    replace_map={
+                        "my_entity": snake_entity_name,
+                        "my_entities": snake_plural_entity_name,
+                        "MyEntity": pascal_entity_name,
+                    },
+                ),
+            ),
         ],
     )
 
 
-def update_api_client(ctx: AnyContext, api_client_file_path: str):
+def _get_import_schema_for_client_code(
+    existing_code: str, entity_name: str
+) -> str | None:
+    snake_entity_name = to_snake_case(entity_name)
+    pascal_entity_name = to_pascal_case(entity_name)
+    schema_import_path = f"my_app_name.schema.{snake_entity_name}"
+    new_code = "\n".join(
+        [
+            f"from {schema_import_path} import (",
+            f"   Multiple{pascal_entity_name}Response,",
+            f"   {pascal_entity_name}Create,",
+            f"   {pascal_entity_name}CreateWithAudit,",
+            f"   {pascal_entity_name}Response,",
+            f"   {pascal_entity_name}Update,",
+            f"   {pascal_entity_name}UpdateWithAudit,",
+            ")",
+        ]
+    )
+    if new_code in existing_code:
+        return None
+    return new_code
+
+
+def update_api_client_file(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)
+    pascal_module_name = to_pascal_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
+            f"from {app_name}.module.{snake_module_name}.service.{snake_entity_name}.{snake_entity_name}_service_factory import {snake_entity_name}_service",  # noqa
             prepend_code_to_module(
                 prepend_parent_class(
-                    existing_api_client_code, "APIClient", "user_api_client"
+                    original_code=existing_api_client_code,
+                    class_name=f"{pascal_module_name}APIClient",
+                    parent_class_name=f"{snake_entity_name}_api_client",
                 ),
-                f"user_api_client = user_usecase.as_api_client(base_url=APP_{upper_snake_module_name}_BASE_URL)",  # noqa
+                f"{snake_entity_name}_api_client = {snake_entity_name}_service.as_api_client(base_url=APP_{upper_snake_module_name}_BASE_URL)",  # noqa
             ),
         ],
     )
 
 
-def update_direct_client(ctx: AnyContext, direct_client_file_path: str):
+def update_direct_client_file(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)
+    pascal_module_name = to_pascal_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
+            f"from {app_name}.module.{snake_module_name}.service.{snake_entity_name}.{snake_entity_name}_service_factory import {snake_entity_name}_service",  # noqa
             prepend_code_to_module(
                 prepend_parent_class(
-                    existing_direct_client_code, "DirectClient", "user_direct_client"
+                    original_code=existing_direct_client_code,
+                    class_name=f"{pascal_module_name}DirectClient",
+                    parent_class_name=f"{snake_entity_name}_direct_client",
                 ),
-                "user_direct_client = user_usecase.as_direct_client()",
+                f"{snake_entity_name}_direct_client = {snake_entity_name}_service.as_direct_client()",  # noqa
             ).strip(),
         ],
     )
 
 
-def update_route(ctx: AnyContext, route_file_path: str):
+def update_route_file(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)
@@ -203,11 +243,79 @@ def update_route(ctx: AnyContext, route_file_path: str):
     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
+            f"from {app_name}.module.{module_name}.service.{entity_name}.{entity_name}_service_factory import {entity_name}_service",  # noqa
             append_code_to_function(
                 existing_route_code,
                 "serve_route",
-                f"{entity_name}_usecase.serve_route(app)",
+                f"{entity_name}_service.serve_route(app)",
+            ),
+        ],
+    )
+
+
+def update_gateway_subroute_file(ctx: AnyContext, module_gateway_subroute_path: str):
+    snake_module_name = to_snake_case(ctx.input.module)
+    snake_entity_name = to_snake_case(ctx.input.entity)
+    snake_plural_entity_name = to_snake_case(ctx.input.plural)
+    kebab_plural_entity_name = to_kebab_case(ctx.input.plural)
+    pascal_entity_name = to_pascal_case(ctx.input.entity)
+    existing_gateway_subroute_code = read_file(module_gateway_subroute_path)
+    write_file(
+        file_path=module_gateway_subroute_path,
+        content=[
+            _get_import_client_for_gateway_subroute_code(
+                existing_gateway_subroute_code, module_name=ctx.input.module
+            ),
+            _get_import_schema_for_gateway_subroute_code(
+                existing_gateway_subroute_code, entity_name=ctx.input.entity
+            ),
+            append_code_to_function(
+                original_code=existing_gateway_subroute_code,
+                function_name=f"serve_{snake_module_name}_route",
+                new_code=read_file(
+                    file_path=os.path.join(
+                        os.path.dirname(__file__), "template", "gateway_subroute.py"
+                    ),
+                    replace_map={
+                        "my_module": snake_module_name,
+                        "my_entity": snake_entity_name,
+                        "my_entities": snake_plural_entity_name,
+                        "my-entities": kebab_plural_entity_name,
+                        "MyEntity": pascal_entity_name,
+                    },
+                ),
             ),
         ],
     )
+
+
+def _get_import_client_for_gateway_subroute_code(
+    existing_code: str, module_name: str
+) -> str | None:
+    snake_module_name = to_snake_case(module_name)
+    client_import_path = f"my_app_name.module.{snake_module_name}.client.{snake_module_name}_client_factory"  # noqa
+    new_code = f"from {client_import_path} import {snake_module_name}_client"
+    if new_code in existing_code:
+        return None
+    return new_code
+
+
+def _get_import_schema_for_gateway_subroute_code(
+    existing_code: str, entity_name: str
+) -> str | None:
+    snake_entity_name = to_snake_case(entity_name)
+    pascal_entity_name = to_pascal_case(entity_name)
+    schema_import_path = f"my_app_name.schema.{snake_entity_name}"
+    new_code = "\n".join(
+        [
+            f"from {schema_import_path} import (",
+            f"   Multiple{pascal_entity_name}Response,",
+            f"   {pascal_entity_name}Create,",
+            f"   {pascal_entity_name}Response,",
+            f"   {pascal_entity_name}Update,",
+            ")",
+        ]
+    )
+    if new_code in existing_code:
+        return None
+    return new_code