zrb 1.0.0b9__tar.gz → 1.1.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zrb
-Version: 1.0.0b9
+Version: 1.1.0
 Summary: Your Automation Powerhouse
 Home-page: https://github.com/state-alchemists/zrb
 License: AGPL-3.0-or-later
@@ -26,7 +26,7 @@ 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)
+Requires-Dist: python-jose[cryptography] (>=3.4.0,<4.0.0)
 Requires-Dist: requests (>=2.32.3,<3.0.0)
 Requires-Dist: ulid-py (>=1.1.0,<2.0.0)
 Project-URL: Documentation, https://github.com/state-alchemists/zrb

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "zrb"
-version = "1.0.0b9"
+version = "1.1.0"
 description = "Your Automation Powerhouse"
 authors = ["Go Frendi Gunawan <gofrendiasgard@gmail.com>"]
 license = "AGPL-3.0-or-later"
@@ -48,7 +48,7 @@ chromadb = {version = "^0.5.20", optional = true}
 pdfplumber = {version = "^0.11.4", optional = true}
 beautifulsoup4 = "^4.12.3"
 fastapi = {extras = ["standard"], version = "^0.115.6"}
-python-jose = {extras = ["cryptography"], version = "^3.3.0"}
+python-jose = {extras = ["cryptography"], version = "^3.4.0"}
 ulid-py = "^1.1.0"
 pydantic-ai = "^0.0.19"
 fastembed = "^0.5.1"
@@ -58,7 +58,7 @@ psutil = "^6.1.1"
 # poetry install -E rag
 rag = ["chromadb", "pdfplumber"]
 
-[tool.poetry.dev-dependencies]
+[tool.poetry.group.dev.dependencies]
 alembic = "^1.14.0" # FastApp dependencies
 flake8 = "~7.1.1"
 pytest = "~8.3.3"

zrb-1.1.0/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/.coveragerc

@@ -0,0 +1,11 @@
+[run]
+omit =
+    _zrb/*
+
+[report]
+# Show missing lines in the terminal report
+show_missing = True
+
+[html]
+# Set the output directory for HTML reports (optional)
+directory = htmlcov 

zrb-1.1.0/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/.gitignore

@@ -0,0 +1,8 @@
+__pycache__
+.venv
+.env
+*.db
+
+htmlcov
+.coverage
+.pytest_cache

zrb-1.1.0/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/column/add_column_task.py

@@ -0,0 +1,137 @@
+import os
+
+from my_app_name._zrb.column.add_column_util import (
+    update_fastapp_schema,
+    update_fastapp_test_create,
+    update_fastapp_test_delete,
+    update_fastapp_test_read,
+    update_fastapp_test_update,
+    update_fastapp_ui,
+)
+from my_app_name._zrb.config import APP_DIR
+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_entity_input,
+    existing_module_input,
+    new_column_input,
+    new_column_type_input,
+)
+from my_app_name._zrb.util import get_existing_module_names, get_existing_schema_names
+
+from zrb import AnyContext, Task, make_task
+
+
+@make_task(
+    name="validate-add-fastapp-column",
+    input=[
+        existing_module_input,
+        existing_entity_input,
+    ],
+    retries=0,
+)
+async def validate_add_fastapp_column(ctx: AnyContext):
+    module_name = ctx.input.module
+    if module_name not in get_existing_module_names():
+        raise ValueError(f"Module not exist: {module_name}")
+    schema_name = ctx.input.entity
+    if schema_name not in get_existing_schema_names():
+        raise ValueError(f"Schema not exist: {schema_name}")
+
+
+update_fastapp_schema_task = Task(
+    name="update-fastapp-schema",
+    input=[
+        existing_module_input,
+        existing_entity_input,
+        new_column_input,
+        new_column_type_input,
+    ],
+    action=update_fastapp_schema,
+    retries=0,
+    upstream=validate_add_fastapp_column,
+)
+
+update_fastapp_ui_task = Task(
+    name="update-fastapp-ui",
+    input=[
+        existing_module_input,
+        existing_entity_input,
+        new_column_input,
+        new_column_type_input,
+    ],
+    action=update_fastapp_ui,
+    retries=0,
+    upstream=validate_add_fastapp_column,
+)
+
+update_fastapp_test_create_task = Task(
+    name="update-fastapp-test-create",
+    input=[
+        existing_module_input,
+        existing_entity_input,
+        new_column_input,
+        new_column_type_input,
+    ],
+    action=update_fastapp_test_create,
+    retries=0,
+    upstream=validate_add_fastapp_column,
+)
+
+update_fastapp_test_read_task = Task(
+    name="update-fastapp-test-read",
+    input=[
+        existing_module_input,
+        existing_entity_input,
+        new_column_input,
+        new_column_type_input,
+    ],
+    action=update_fastapp_test_read,
+    retries=0,
+    upstream=validate_add_fastapp_column,
+)
+
+update_fastapp_test_update_task = Task(
+    name="update-fastapp-test-update",
+    input=[
+        existing_module_input,
+        existing_entity_input,
+        new_column_input,
+        new_column_type_input,
+    ],
+    action=update_fastapp_test_update,
+    retries=0,
+    upstream=validate_add_fastapp_column,
+)
+
+update_fastapp_test_delete_task = Task(
+    name="update-fastapp-test-delete",
+    input=[
+        existing_module_input,
+        existing_entity_input,
+        new_column_input,
+        new_column_type_input,
+    ],
+    action=update_fastapp_test_delete,
+    retries=0,
+    upstream=validate_add_fastapp_column,
+)
+
+
+add_fastapp_column = app_create_group.add_task(
+    Task(
+        name="add-fastapp-column",
+        description="📊 Create new column on an entity",
+        upstream=[
+            update_fastapp_schema_task,
+            update_fastapp_ui_task,
+            update_fastapp_test_create_task,
+            update_fastapp_test_read_task,
+            update_fastapp_test_update_task,
+            update_fastapp_test_delete_task,
+        ],
+        successor=format_my_app_name_code,
+        retries=0,
+    ),
+    alias="column",
+)

zrb-1.1.0/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/column/add_column_util.py

@@ -0,0 +1,301 @@
+import os
+import re
+import textwrap
+
+from bs4 import BeautifulSoup, formatter
+from my_app_name._zrb.config import APP_DIR
+
+from zrb.context.any_context import AnyContext
+from zrb.util.codemod.modify_class import append_code_to_class
+from zrb.util.codemod.modify_class_parent import prepend_parent_class
+from zrb.util.codemod.modify_class_property import append_property_to_class
+from zrb.util.codemod.modify_function import append_code_to_function
+from zrb.util.codemod.modify_module import prepend_code_to_module
+from zrb.util.file import read_file, write_file
+from zrb.util.string.conversion import (
+    to_human_case,
+    to_kebab_case,
+    to_pascal_case,
+    to_snake_case,
+)
+
+
+def update_fastapp_schema(ctx: AnyContext):
+    snake_entity_name = to_snake_case(ctx.input.entity)
+    pascal_entity_name = to_pascal_case(ctx.input.entity)
+    snake_column_name = to_snake_case(ctx.input.column)
+    column_type = ctx.input.type
+    schema_file_path = os.path.join(APP_DIR, "schema", f"{snake_entity_name}.py")
+    existing_code = read_file(schema_file_path)
+    # Base
+    new_code = append_property_to_class(
+        original_code=existing_code,
+        class_name=f"{pascal_entity_name}Base",
+        property_name=snake_column_name,
+        annotation=column_type,
+        default_value=_get_default_column_value(column_type),
+    )
+    # Update
+    new_code = append_property_to_class(
+        original_code=new_code,
+        class_name=f"{pascal_entity_name}Update",
+        property_name=snake_column_name,
+        annotation=f"{column_type} | None",
+        default_value="None",
+    )
+    # Table
+    new_code = append_property_to_class(
+        original_code=new_code,
+        class_name=f"{pascal_entity_name}",
+        property_name=snake_column_name,
+        annotation=f"{column_type} | None",
+        default_value="Field(index=False)",
+    )
+    write_file(schema_file_path, new_code)
+
+
+def _get_default_column_value(data_type: str) -> str:
+    if data_type == "str":
+        return '""'
+    if data_type in ("int", "float"):
+        return "0"
+    if data_type == "bool":
+        return "True"
+    return "None"
+
+
+def update_fastapp_ui(ctx: AnyContext):
+    kebab_module_name = to_kebab_case(ctx.input.module)
+    kebab_entity_name = to_kebab_case(ctx.input.entity)
+    snake_column_name = to_snake_case(ctx.input.column)
+    human_column_name = to_human_case(ctx.input.column).title()
+    subroute_file_path = os.path.join(
+        APP_DIR,
+        "module",
+        "gateway",
+        "view",
+        "content",
+        kebab_module_name,
+        f"{kebab_entity_name}.html",
+    )
+    existing_code = read_file(subroute_file_path)
+    # Add table header
+    new_code = _add_th_before_last(
+        existing_code, table_id="crud-table", th_content=human_column_name
+    )
+    # Forms
+    new_code = _add_input_to_form(
+        new_code,
+        form_id="crud-create-form",
+        column_label=human_column_name,
+        column_name=snake_column_name,
+    )
+    new_code = _add_input_to_form(
+        new_code,
+        form_id="crud-update-form",
+        column_label=human_column_name,
+        column_name=snake_column_name,
+    )
+    new_code = _add_input_to_form(
+        new_code,
+        form_id="crud-delete-form",
+        column_label=human_column_name,
+        column_name=snake_column_name,
+    )
+    # JS Function
+    new_code = _alter_js_function_returned_array(
+        new_code,
+        js_function_name="getRowComponents",
+        js_array_name="rowComponents",
+        js_new_value=f"`<td>${{row.{snake_column_name}}}</td>`",
+    )
+    write_file(subroute_file_path, new_code)
+
+
+def _add_th_before_last(html_str, table_id, th_content):
+    # Use the html.parser; you might try html5lib if you find that it preserves formatting better.
+    soup = BeautifulSoup(html_str, "html.parser")
+    # Locate the table with the specified id
+    table = soup.find("table", id=table_id)
+    if not table:
+        # Table not found; return original HTML unchanged.
+        return html_str
+    # Find the thead element in the table.
+    thead = table.find("thead")
+    if not thead:
+        return html_str
+    # For this example, we assume there's a single row (<tr>) in the thead.
+    row = thead.find("tr")
+    if not row:
+        return html_str
+    # Find all existing th elements in the row.
+    th_elements = row.find_all("th")
+    if not th_elements:
+        return html_str
+    # Create a new th element and set its content.
+    new_th = soup.new_tag("th")
+    new_th.string = th_content
+    # Insert the new th right before the last existing th.
+    th_elements[-1].insert_before(new_th)
+    # Return the modified HTML as a string.
+    return soup.prettify(
+        formatter=formatter.HTMLFormatter(indent=_infer_html_indent_width(html_str))
+    )
+
+
+def _add_input_to_form(
+    html_str: str, form_id: str, column_label: str, column_name: str
+) -> str:
+    soup = BeautifulSoup(html_str, "html.parser")
+    # Find the form by id.
+    form = soup.find("form", id=form_id)
+    if not form:
+        return html_str  # Return unchanged if no matching form is found.
+    # Create a new label element with the provided column label.
+    new_label = soup.new_tag("label")
+    new_label.append(f"{column_label}: ")
+    # Create a new input element with the provided column name.
+    new_input = soup.new_tag(
+        "input", attrs={"type": "text", "name": column_name, "required": "required"}
+    )
+    new_label.append(new_input)
+    # Look for a footer element inside the form.
+    footer = form.find("footer")
+    if footer:
+        # Insert the new label before the footer.
+        footer.insert_before(new_label)
+    else:
+        # If no footer exists, simply append the new label to the form.
+        form.append(new_label)
+    return soup.prettify(
+        formatter=formatter.HTMLFormatter(indent=_infer_html_indent_width(html_str))
+    )
+
+
+def _infer_html_indent_width(html_str: str) -> int:
+    """
+    Infer the indentation width (number of spaces) from the HTML string.
+    It looks for the first non-empty line that starts with whitespace
+    followed by '<' and returns the number of leading spaces.
+    If none is found, defaults to 2.
+    """
+    for line in textwrap.dedent(html_str).splitlines():
+        stripped = line.lstrip()
+        if stripped.startswith("<") and line != stripped:
+            return len(line) - len(stripped)
+    return 2
+
+
+def _alter_js_function_returned_array(
+    html_str: str, js_function_name: str, js_array_name: str, js_new_value: str
+) -> str:
+    """
+    Inserts a new push into the specified JavaScript function.
+
+    It finds the function definition with the given js_function_name,
+    then looks for the first return statement inside the function body,
+    and inserts a new line that pushes js_new_value into js_arr_name.
+
+    Parameters:
+        html_str (str): The HTML containing the JavaScript.
+        js_function_name (str): The name of the JavaScript function to modify.
+        js_arr_name (str): The name of the array inside that function.
+        js_new_value (str): The new value to push. (Pass the JS literal as a string,
+                            e.g. "`<td>NEW</td>`" or '"<td>NEW</td>"'.)
+
+    Returns:
+        str: The modified HTML.
+    """
+    # This pattern finds:
+    #  1. The function signature and opening brace.
+    #  2. All content (non-greedily) until we hit a newline containing a return statement.
+    #  3. Captures the newline and leading whitespace (indent) of the return statement.
+    #  4. Captures the rest of the return line.
+    pattern = (
+        r"(function\s+"
+        + re.escape(js_function_name)
+        + r"\s*\([^)]*\)\s*\{)"  # group1: function header
+        r"([\s\S]*?)"  # group2: code before return
+        r"(\n(\s*)return\s+[^;]+;)"  # group3: newline+return line, group4: indent
+    )
+
+    def replacer(match):
+        header = match.group(1)
+        before_return = match.group(2)
+        return_line = match.group(3)
+        indent = match.group(4)
+        # Create the new push statement. We add a newline plus the same indent.
+        # The resulting line will be, e.g.,
+        # "        rowComponents.push(`<td>NEW</td>`);"
+        injection = f"\n{indent}{js_array_name}.push({js_new_value});"
+        return header + before_return + injection + return_line
+
+    # Use re.sub to replace only the first occurrence of the function
+    new_html, count = re.subn(
+        pattern, replacer, html_str, count=1, flags=re.MULTILINE | re.DOTALL
+    )
+    return new_html
+
+
+def update_fastapp_test_create(ctx: AnyContext):
+    snake_module_name = to_snake_case(ctx.input.module)
+    snake_entity_name = to_snake_case(ctx.input.entity)
+    test_file_path = os.path.join(
+        APP_DIR,
+        "test",
+        snake_module_name,
+        snake_entity_name,
+        f"test_create_{snake_entity_name}.py",
+    )
+    existing_code = read_file(test_file_path)
+    new_code = existing_code
+    # TODO: update test
+    write_file(test_file_path, new_code)
+
+
+def update_fastapp_test_read(ctx: AnyContext):
+    snake_module_name = to_snake_case(ctx.input.module)
+    snake_entity_name = to_snake_case(ctx.input.entity)
+    test_file_path = os.path.join(
+        APP_DIR,
+        "test",
+        snake_module_name,
+        snake_entity_name,
+        f"test_read_{snake_entity_name}.py",
+    )
+    existing_code = read_file(test_file_path)
+    new_code = existing_code
+    # TODO: update test
+    write_file(test_file_path, new_code)
+
+
+def update_fastapp_test_update(ctx: AnyContext):
+    snake_module_name = to_snake_case(ctx.input.module)
+    snake_entity_name = to_snake_case(ctx.input.entity)
+    test_file_path = os.path.join(
+        APP_DIR,
+        "test",
+        snake_module_name,
+        snake_entity_name,
+        f"test_update_{snake_entity_name}.py",
+    )
+    existing_code = read_file(test_file_path)
+    new_code = existing_code
+    # TODO: update test
+    write_file(test_file_path, new_code)
+
+
+def update_fastapp_test_delete(ctx: AnyContext):
+    snake_module_name = to_snake_case(ctx.input.module)
+    snake_entity_name = to_snake_case(ctx.input.entity)
+    test_file_path = os.path.join(
+        APP_DIR,
+        "test",
+        snake_module_name,
+        snake_entity_name,
+        f"test_delete_{snake_entity_name}.py",
+    )
+    existing_code = read_file(test_file_path)
+    new_code = existing_code
+    # TODO: update test
+    write_file(test_file_path, new_code)

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

@@ -13,6 +13,11 @@ MONOLITH_ENV_VARS = {
     "MY_APP_NAME_MODE": "monolith",
     "MY_APP_NAME_MODULES": "",
 }
+TEST_ENV_VARS = {
+    "MY_APP_NAME_DB_URL": f"sqlite:///{APP_DIR}/test.db",
+    "MY_APP_NAME_AUTH_PRIORITIZE_NEW_SESSION": "1",  # Need this because we will launch a new user session for each test
+    "MY_APP_NAME_AUTH_GUEST_USER_PERMISSIONs": "",  # Guest user should not has any privilege for testing
+}
 
 if platform.system() == "Windows":
     ACTIVATE_VENV_SCRIPT = "Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser; . .venv\\Scripts\\Activate"  # noqa