zrb 1.0.0b5__tar.gz → 1.0.0b7__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zrb
-Version: 1.0.0b5
+Version: 1.0.0b7
 Summary: Your Automation Powerhouse
 Home-page: https://github.com/state-alchemists/zrb
 License: AGPL-3.0-or-later
@@ -19,6 +19,7 @@ Requires-Dist: beautifulsoup4 (>=4.12.3,<5.0.0)
 Requires-Dist: black (>=24.10.0,<24.11.0)
 Requires-Dist: chromadb (>=0.5.20,<0.6.0) ; extra == "rag"
 Requires-Dist: fastapi[standard] (>=0.115.6,<0.116.0)
+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"

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

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

{zrb-1.0.0b5 → zrb-1.0.0b7}/src/zrb/builtin/__init__.py

@@ -17,6 +17,7 @@ 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
 from zrb.builtin.setup.ubuntu import setup_ubuntu
+from zrb.builtin.setup.zsh.zsh import setup_zsh
 from zrb.builtin.shell.autocomplete.bash import make_bash_autocomplete
 from zrb.builtin.shell.autocomplete.subcmd import get_shell_subcommands
 from zrb.builtin.shell.autocomplete.zsh import make_zsh_autocomplete
@@ -62,3 +63,4 @@ assert setup_ubuntu
 assert setup_latex_on_ubuntu
 assert setup_asdf
 assert setup_tmux
+assert setup_zsh

{zrb-1.0.0b5 → zrb-1.0.0b7}/src/zrb/builtin/llm/tool/rag.py

@@ -3,7 +3,6 @@ import json
 import os
 import sys
 
-import litellm
 import ulid
 
 from zrb.config import (
@@ -30,7 +29,9 @@ def create_rag_from_directory(
     async def retrieve(query: str) -> str:
         from chromadb import PersistentClient
         from chromadb.config import Settings
+        from fastembed import TextEmbedding
 
+        embedding_model = TextEmbedding(model_name=model)
         client = PersistentClient(
             path=vector_db_path, settings=Settings(allow_reset=True)
         )
@@ -75,10 +76,8 @@ def create_rag_from_directory(
                                 ),
                                 file=sys.stderr,
                             )
-                            response = await litellm.aembedding(
-                                model=model, input=[chunk]
-                            )
-                            vector = response["data"][0]["embedding"]
+                            embedding_result = list(embedding_model.embed([chunk]))
+                            vector = embedding_result[0]
                             collection.upsert(
                                 ids=[chunk_id],
                                 embeddings=[vector],
@@ -102,9 +101,8 @@ def create_rag_from_directory(
             )
 
         print(stylize_faint("Vectorizing query"), file=sys.stderr)
-        query_response = await litellm.aembedding(model=model, input=[query])
-        query_vector = query_response["data"][0]["embedding"]
-
+        embedding_result = list(embedding_model.embed([query]))
+        query_vector = embedding_result[0]
         print(stylize_faint("Searching documents"), file=sys.stderr)
         results = collection.query(
             query_embeddings=query_vector,

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

@@ -20,11 +20,11 @@ from zrb.util.string.name import get_random_name
 
 
 @make_task(
-    name="validate-create-fastapp",
+    name="validate-add-fastapp",
     input=[project_dir_input, app_name_input],
     retries=0,
 )
-async def validate_create_fastapp(ctx: AnyContext):
+async def validate_add_fastapp(ctx: AnyContext):
     project_dir = ctx.input.project_dir
     if not os.path.isdir(project_dir):
         raise ValueError(f"Project directory not exists: {project_dir}")
@@ -39,7 +39,7 @@ scaffold_fastapp = Scaffolder(
         project_dir_input,
         app_name_input,
     ],
-    upstream=validate_create_fastapp,
+    upstream=validate_add_fastapp,
     source_path=os.path.join(os.path.dirname(__file__), "fastapp_template"),
     render_source_path=False,
     destination_path="{ctx.input.project_dir}",

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

@@ -0,0 +1,93 @@
+import os
+
+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,
+    new_column_input,
+    new_column_type_input,
+)
+from my_app_name._zrb.util import get_existing_schema_names
+
+from zrb import AnyContext, Task, make_task
+from zrb.util.codemod.prepend_property_to_class import prepend_property_to_class
+from zrb.util.file import read_file, write_file
+from zrb.util.string.conversion import to_pascal_case, to_snake_case
+
+
+@make_task(
+    name="validate-add-my-app-name-column",
+    input=existing_entity_input,
+    retries=0,
+)
+async def validate_add_my_app_name_column(ctx: AnyContext):
+    schema_name = ctx.input.entity
+    if schema_name not in get_existing_schema_names():
+        raise ValueError(f"Schema not exist: {schema_name}")
+
+
+@make_task(
+    name="update-my-app-name-schema",
+    input=[
+        existing_entity_input,
+        new_column_input,
+        new_column_type_input,
+    ],
+    retries=0,
+    upstream=validate_add_my_app_name_column,
+)
+def update_my_app_name_schema(ctx: AnyContext):
+    snake_entity_name = to_snake_case(ctx.input.entity)
+    pascal_entity_name = to_pascal_case(ctx.input.entity)
+    schema_file_path = os.path.join(APP_DIR, "schema", f"{snake_entity_name}.py")
+    existing_code = read_file(schema_file_path)
+    snake_column_name = to_snake_case(ctx.input.column)
+    column_type = ctx.input.type
+    # Base
+    new_code = prepend_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_value(column_type),
+    )
+    # Update
+    new_code = prepend_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 = prepend_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)
+
+
+add_my_app_name_column = app_create_group.add_task(
+    Task(
+        name="add-my-app-name-column",
+        description="📊 Create new column on an entity",
+        upstream=update_my_app_name_schema,
+        successor=format_my_app_name_code,
+        retries=0,
+    ),
+    alias="column",
+)
+
+
+def _get_default_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"

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

@@ -48,7 +48,7 @@ from zrb.util.string.conversion import to_snake_case
 
 
 @make_task(
-    name="validate-create-my-app-name-entity",
+    name="validate-add-my-app-name-entity",
     input=[
         existing_module_input,
         new_entity_input,
@@ -57,7 +57,7 @@ from zrb.util.string.conversion import to_snake_case
     ],
     retries=0,
 )
-async def validate_create_my_app_name_entity(ctx: AnyContext):
+async def validate_add_my_app_name_entity(ctx: AnyContext):
     module_name = to_snake_case(ctx.input.module)
     if module_name not in get_existing_module_names():
         raise ValueError(f"Module not exist: {module_name}")
@@ -147,7 +147,7 @@ scaffold_my_app_name_entity = Scaffolder(
         ),
     ],
     retries=0,
-    upstream=validate_create_my_app_name_entity,
+    upstream=validate_add_my_app_name_entity,
 )
 
 create_my_app_name_entity_migration = CmdTask(

{zrb-1.0.0b5 → zrb-1.0.0b7}/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

@@ -72,10 +72,8 @@ class MyEntityService(BaseService):
     async def update_my_entity_bulk(
         self, my_entity_ids: list[str], data: MyEntityUpdateWithAudit
     ) -> MyEntityResponse:
-        my_entities = await self.my_entity_repository.update_bulk(my_entity_ids, data)
-        return await self.my_entity_repository.get_by_ids(
-            [my_entity.id for my_entity in my_entities]
-        )
+        await self.my_entity_repository.update_bulk(my_entity_ids, data)
+        return await self.my_entity_repository.get_by_ids(my_entity_ids)
 
     @BaseService.route(
         "/api/v1/my-entities/{my_entity_id}",
@@ -85,21 +83,20 @@ class MyEntityService(BaseService):
     async def update_my_entity(
         self, my_entity_id: str, data: MyEntityUpdateWithAudit
     ) -> MyEntityResponse:
-        my_entity = await self.my_entity_repository.update(my_entity_id, data)
-        return await self.my_entity_repository.get_by_id(my_entity.id)
+        await self.my_entity_repository.update(my_entity_id, data)
+        return await self.my_entity_repository.get_by_id(my_entity_id)
 
     @BaseService.route(
-        "/api/v1/my-entities/{my_entity_id}",
+        "/api/v1/my-entities/bulk",
         methods=["delete"],
         response_model=MyEntityResponse,
     )
     async def delete_my_entity_bulk(
         self, my_entity_ids: list[str], deleted_by: str
     ) -> MyEntityResponse:
-        my_entities = await self.my_entity_repository.delete_bulk(my_entity_ids)
-        return await self.my_entity_repository.get_by_ids(
-            [my_entity.id for my_entity in my_entities]
-        )
+        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
 
     @BaseService.route(
         "/api/v1/my-entities/{my_entity_id}",
@@ -109,5 +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.delete(my_entity_id)
-        return 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.0b5 → zrb-1.0.0b7}/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/_zrb/module/add_module_task.py

@@ -24,11 +24,11 @@ from zrb import AnyContext, ContentTransformer, Scaffolder, Task, make_task
 
 
 @make_task(
-    name="validate-create-my-app-name-module",
+    name="validate-add-my-app-name-module",
     input=new_module_input,
     retries=0,
 )
-async def validate_create_my_app_name_module(ctx: AnyContext):
+async def validate_add_my_app_name_module(ctx: AnyContext):
     if ctx.input.module in get_existing_module_names():
         raise ValueError(f"Module already exists: {ctx.input.module}")
 
@@ -93,7 +93,7 @@ scaffold_my_app_name_module = Scaffolder(
         ),
     ],
     retries=0,
-    upstream=validate_create_my_app_name_module,
+    upstream=validate_add_my_app_name_module,
 )
 
 add_my_app_name_module = app_create_group.add_task(

{zrb-1.0.0b5 → zrb-1.0.0b7}/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/service/permission/permission_service.py

@@ -76,10 +76,8 @@ class PermissionService(BaseService):
     async def update_permission_bulk(
         self, permission_ids: list[str], data: PermissionUpdateWithAudit
     ) -> PermissionResponse:
-        permissions = await self.permission_repository.update_bulk(permission_ids, data)
-        return await self.permission_repository.get_by_ids(
-            [permission.id for permission in permissions]
-        )
+        await self.permission_repository.update_bulk(permission_ids, data)
+        return await self.permission_repository.get_by_ids(permission_ids)
 
     @BaseService.route(
         "/api/v1/permissions/{permission_id}",
@@ -89,21 +87,20 @@ class PermissionService(BaseService):
     async def update_permission(
         self, permission_id: str, data: PermissionUpdateWithAudit
     ) -> PermissionResponse:
-        permission = await self.permission_repository.update(permission_id, data)
-        return await self.permission_repository.get_by_id(permission.id)
+        await self.permission_repository.update(permission_id, data)
+        return await self.permission_repository.get_by_id(permission_id)
 
     @BaseService.route(
-        "/api/v1/permissions/{permission_id}",
+        "/api/v1/permissions/bulk",
         methods=["delete"],
         response_model=PermissionResponse,
     )
     async def delete_permission_bulk(
         self, permission_ids: list[str], deleted_by: str
     ) -> PermissionResponse:
-        permissions = await self.permission_repository.delete_bulk(permission_ids)
-        return await self.permission_repository.get_by_ids(
-            [permission.id for permission in permissions]
-        )
+        permissions = await self.permission_repository.get_by_ids(permission_ids)
+        await self.permission_repository.delete_bulk(permission_ids)
+        return permissions
 
     @BaseService.route(
         "/api/v1/permissions/{permission_id}",
@@ -113,5 +110,6 @@ class PermissionService(BaseService):
     async def delete_permission(
         self, permission_id: str, deleted_by: str
     ) -> PermissionResponse:
-        permission = await self.permission_repository.delete(permission_id)
-        return await self.permission_repository.get_by_id(permission.id)
+        permission = await self.permission_repository.get_by_id(permission_id)
+        await self.permission_repository.delete(permission_id)
+        return permission

{zrb-1.0.0b5 → zrb-1.0.0b7}/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/service/role/role_service.py

@@ -87,17 +87,15 @@ class RoleService(BaseService):
     ) -> RoleResponse:
         permission_ids = [row.get_permission_ids() for row in data]
         data = [row.get_role_update_with_audit() for row in data]
-        roles = await self.role_repository.update_bulk(role_ids, data)
-        if len(roles) > 0:
-            updated_by = roles[0].updated_by
-            await self.role_repository.remove_all_permissions(
-                [role.id for role in roles]
-            )
+        await self.role_repository.update_bulk(role_ids, data)
+        if len(role_ids) > 0:
+            updated_by = data[0].updated_by
+            await self.role_repository.remove_all_permissions(role_ids)
             await self.role_repository.add_permissions(
-                data={role.id: permission_ids[i] for i, role in enumerate(roles)},
+                data={role_id: permission_ids[i] for i, role_id in enumerate(role_ids)},
                 created_by=updated_by,
             )
-        return await self.role_repository.get_by_ids([role.id for role in roles])
+        return await self.role_repository.get_by_ids(role_ids)
 
     @BaseService.route(
         "/api/v1/roles/{role_id}",
@@ -108,24 +106,26 @@ class RoleService(BaseService):
         self, role_id: str, data: RoleUpdateWithPermissionsAndAudit
     ) -> RoleResponse:
         permission_ids = data.get_permission_ids()
-        data = data.get_role_update_with_audit()
-        role = await self.role_repository.update(role_id, data)
-        await self.role_repository.remove_all_permissions([role.id])
+        role_data = data.get_role_update_with_audit()
+        await self.role_repository.update(role_id, role_data)
+        await self.role_repository.remove_all_permissions([role_id])
         await self.role_repository.add_permissions(
-            data={role.id: permission_ids}, created_by=role.updated_by
+            data={role_id: permission_ids}, created_by=role_data.updated_by
         )
-        return await self.role_repository.get_by_id(role.id)
+        return await self.role_repository.get_by_id(role_id)
 
     @BaseService.route(
-        "/api/v1/roles/{role_id}",
+        "/api/v1/roles/bulk",
         methods=["delete"],
         response_model=RoleResponse,
     )
     async def delete_role_bulk(
         self, role_ids: list[str], deleted_by: str
     ) -> RoleResponse:
-        roles = await self.role_repository.delete_bulk(role_ids)
-        return await self.role_repository.get_by_ids([role.id for role in roles])
+        roles = await self.role_repository.get_by_ids(role_ids)
+        await self.role_repository.delete_bulk(role_ids)
+        await self.role_repository.remove_all_permissions(role_ids)
+        return roles
 
     @BaseService.route(
         "/api/v1/roles/{role_id}",
@@ -133,5 +133,7 @@ class RoleService(BaseService):
         response_model=RoleResponse,
     )
     async def delete_role(self, role_id: str, deleted_by: str) -> RoleResponse:
-        role = await self.role_repository.delete(role_id)
-        return await self.role_repository.get_by_id(role.id)
+        role = await self.role_repository.get_by_id(role_id)
+        await self.role_repository.delete(role_id)
+        await self.role_repository.remove_all_permissions([role_id])
+        return role

{zrb-1.0.0b5 → zrb-1.0.0b7}/src/zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/service/user/user_service.py

@@ -84,16 +84,16 @@ class UserService(BaseService):
         self, user_ids: list[str], data: UserUpdateWithRolesAndAudit
     ) -> UserResponse:
         role_ids = [row.get_role_ids() for row in data]
-        data = [row.get_user_create_with_audit() for row in data]
-        users = await self.user_repository.update_bulk(user_ids, data)
-        if len(users) > 0:
-            updated_by = users[0].updated_by
-            await self.user_repository.remove_all_roles([user.id for user in users])
+        user_data = [row.get_user_create_with_audit() for row in data]
+        await self.user_repository.update_bulk(user_ids, user_data)
+        if len(user_ids) > 0:
+            updated_by = user_data[0].updated_by
+            await self.user_repository.remove_all_roles(user_ids)
             await self.user_repository.add_roles(
-                data={user.id: role_ids[i] for i, user in enumerate(data)},
+                data={user_id: role_ids[i] for i, user_id in enumerate(user_ids)},
                 updated_by=updated_by,
             )
-        return await self.user_repository.get_by_ids([user.id for user in users])
+        return await self.user_repository.get_by_ids(user_ids)
 
     @BaseService.route(
         "/api/v1/users/{user_id}",
@@ -103,19 +103,27 @@ class UserService(BaseService):
     async def update_user(
         self, user_id: str, data: UserUpdateWithRolesAndAudit
     ) -> UserResponse:
-        user = await self.user_repository.update(user_id, data)
-        return await self.user_repository.get_by_id(user.id)
+        role_ids = data.get_role_ids()
+        user_data = data.get_user_update_with_audit()
+        await self.user_repository.update(user_id, user_data)
+        await self.user_repository.remove_all_roles([user_id])
+        await self.user_repository.add_roles(
+            data={user_id: role_ids}, created_by=user_data.updated_by
+        )
+        return await self.user_repository.get_by_id(user_id)
 
     @BaseService.route(
-        "/api/v1/users/{user_id}",
+        "/api/v1/users/bulk",
         methods=["delete"],
         response_model=UserResponse,
     )
     async def delete_user_bulk(
         self, user_ids: list[str], deleted_by: str
     ) -> UserResponse:
-        users = await self.user_repository.delete_bulk(user_ids)
-        return await self.user_repository.get_by_ids([user.id for user in users])
+        roles = await self.user_repository.get_by_ids(user_ids)
+        await self.user_repository.delete_bulk(user_ids)
+        await self.user_repository.remove_all_roles(user_ids)
+        return roles
 
     @BaseService.route(
         "/api/v1/users/{user_id}",
@@ -123,5 +131,7 @@ class UserService(BaseService):
         response_model=UserResponse,
     )
     async def delete_user(self, user_id: str, deleted_by: str) -> UserResponse:
-        user = await self.user_repository.delete(user_id)
-        return await self.user_repository.get_by_id(user.id)
+        user = await self.user_repository.get_by_id(user_id)
+        await self.user_repository.delete(user_id)
+        await self.user_repository.remove_all_roles([user_id])
+        return user

{zrb-1.0.0b5 → zrb-1.0.0b7}/src/zrb/builtin/setup/tmux/tmux.py

@@ -24,7 +24,7 @@ install_tmux = CmdTask(
         prompt="Tmux config file",
         default_str="~/.tmux.conf",
     ),
-    description="🖥️ Setup `tmux`.",
+    description="📺 Setup `tmux`.",
     group=setup_group,
     alias="tmux",
 )

zrb-1.0.0b7/src/zrb/builtin/setup/zsh/zsh.py

@@ -0,0 +1,55 @@
+import os
+
+from zrb.builtin.group import setup_group
+from zrb.builtin.setup.common_input import package_manager_input, use_sudo_input
+from zrb.builtin.setup.zsh.zsh_helper import get_install_zsh_cmd
+from zrb.context.any_context import AnyContext
+from zrb.input.str_input import StrInput
+from zrb.task.cmd_task import CmdTask
+from zrb.task.make_task import make_task
+from zrb.util.file import read_file, write_file
+
+install_zsh = CmdTask(
+    name="install-zsh",
+    input=[package_manager_input, use_sudo_input],
+    cmd=get_install_zsh_cmd,
+)
+
+install_omz = CmdTask(
+    name="install-omz",
+    cmd='sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"',  # noqa
+    upstream=install_zsh,
+)
+
+install_zinit = CmdTask(
+    name="install-zinit",
+    cmd='bash -c "$(curl --fail --show-error --silent --location https://raw.githubusercontent.com/zdharma-continuum/zinit/HEAD/scripts/install.sh)"',  # noqa
+    upstream=install_zsh,
+)
+
+
+@make_task(
+    name="setup-zsh",
+    input=StrInput(
+        name="zsh-config",
+        description="zsh config file",
+        prompt="zsh config file",
+        default_str="~/.zshrc",
+    ),
+    upstream=[install_omz, install_zinit],
+    description="💻 Setup `zsh`.",
+    group=setup_group,
+    alias="zsh",
+)
+def setup_zsh(ctx: AnyContext):
+    zsh_config = read_file(os.path.join(os.path.dirname(__file__), "zsh_config.sh"))
+    zsh_config_file = os.path.expanduser(ctx.input["zsh-config"])
+    # Make sure config file exists
+    if not os.path.isfile(zsh_config_file):
+        write_file(zsh_config_file, "")
+    content = read_file(zsh_config_file)
+    if zsh_config in content:
+        return
+    # Write config
+    write_file(zsh_config_file, [content, zsh_config, ""])
+    ctx.print("Setup complete, restart your terminal to continue")