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

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/service/user/repository/user_db_repository.py

@@ -1,11 +1,23 @@
-from typing import Any
+import datetime
+from typing import Any, Callable
 
+import ulid
 from my_app_name.common.base_db_repository import BaseDBRepository
+from my_app_name.common.error import NotFoundError
+from my_app_name.config import (
+    APP_AUTH_GUEST_USER,
+    APP_AUTH_GUEST_USER_PERMISSIONS,
+    APP_AUTH_SUPER_USER,
+    APP_AUTH_SUPER_USER_PASSWORD,
+    APP_MAX_PARALLEL_SESSION,
+    APP_SESSION_EXPIRE_MINUTES,
+)
 from my_app_name.module.auth.service.user.repository.user_repository import (
     UserRepository,
 )
 from my_app_name.schema.permission import Permission
 from my_app_name.schema.role import Role, RolePermission
+from my_app_name.schema.session import Session, SessionResponse
 from my_app_name.schema.user import (
     User,
     UserCreateWithAudit,
@@ -14,8 +26,10 @@ from my_app_name.schema.user import (
     UserUpdateWithAudit,
 )
 from passlib.context import CryptContext
-from sqlalchemy.sql import Select
-from sqlmodel import select
+from sqlalchemy.engine import Engine
+from sqlalchemy.ext.asyncio import AsyncEngine
+from sqlalchemy.sql import ClauseElement, ColumnElement, Select
+from sqlmodel import SQLModel, delete, insert, select
 
 # Password hashing context
 pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
@@ -36,39 +50,163 @@ class UserDBRepository(
     entity_name = "user"
     column_preprocessors = {"password": hash_password}
 
+    def __init__(
+        self,
+        engine: Engine | AsyncEngine,
+        super_user_username: str = APP_AUTH_SUPER_USER,
+        super_user_password: str = APP_AUTH_SUPER_USER_PASSWORD,
+        guest_user_username: str = APP_AUTH_GUEST_USER,
+        guest_user_password: str = APP_AUTH_SUPER_USER_PASSWORD,
+        guest_user_permission_names: list[str] = APP_AUTH_GUEST_USER_PERMISSIONS,
+        max_parallel_session: int = APP_MAX_PARALLEL_SESSION,
+        session_expire_minutes: int = APP_SESSION_EXPIRE_MINUTES,
+        filter_param_parser: (
+            Callable[[SQLModel, str], list[ClauseElement]] | None
+        ) = None,
+        sort_param_parser: Callable[[SQLModel, str], list[ColumnElement]] | None = None,
+    ):
+        super().__init__(
+            engine=engine,
+            filter_param_parser=filter_param_parser,
+            sort_param_parser=sort_param_parser,
+        )
+        self._super_user_username = super_user_username
+        self._super_user_passwored = super_user_password
+        self._guest_user_username = guest_user_username
+        self._guest_user_password = guest_user_password
+        self._guest_user_permission_names = guest_user_permission_names
+        self._max_parallel_session = max_parallel_session
+        self._session_expire_minutes = session_expire_minutes
+        self._super_user: User | None = None
+        self._guest_user: User | None = None
+
     def _select(self) -> Select:
         return (
-            select(User, Role, Permission)
+            select(User, Role, Permission, Session)
             .join(UserRole, UserRole.user_id == User.id, isouter=True)
             .join(Role, Role.id == UserRole.role_id, isouter=True)
             .join(RolePermission, RolePermission.role_id == Role.id, isouter=True)
-            .join(Permission, Permission.id == RolePermission.role_id, isouter=True)
+            .join(
+                Permission, Permission.id == RolePermission.permission_id, isouter=True
+            )
+            .join(Session, Session.user_id == User.id)
         )
 
-    def _rows_to_responses(
-        self, rows: list[tuple[User, Role, Permission]]
-    ) -> UserResponse:
+    def _rows_to_responses(self, rows: list[tuple[Any, ...]]) -> list[UserResponse]:
         user_map: dict[str, dict[str, Any]] = {}
-        for user, role, permission in rows:
+        user_role_map: dict[str, list[str]] = {}
+        user_permission_map: dict[str, list[str]] = {}
+        for user, role, permission, _ in rows:
             if user.id not in user_map:
-                user_map[user.id] = {"user": user, "roles": set(), "permissions": set()}
-            if role:
-                user_map[user.id]["roles"].add(role)
-            if permission:
-                user_map[user.id]["permissions"].add(permission)
+                user_map[user.id] = {"user": user, "roles": [], "permissions": []}
+                user_role_map[user.id] = []
+                user_permission_map[user.id] = []
+            if role is not None and role.id not in user_role_map[user.id]:
+                user_role_map[user.id].append(role.id)
+                user_map[user.id]["roles"].append(role.model_dump())
+            if (
+                permission is not None
+                and permission.id not in user_permission_map[user.id]
+            ):
+                user_permission_map[user.id].append(permission.id)
+                user_map[user.id]["permissions"].append(permission.model_dump())
         return [
             UserResponse(
                 **data["user"].model_dump(),
                 roles=list(data["roles"]),
-                permissions=list(data["permissions"])
+                permissions=list(data["permissions"]),
             )
             for data in user_map.values()
         ]
 
+    async def add_roles(self, data: dict[str, list[str]], created_by: str):
+        now = datetime.datetime.now(datetime.timezone.utc)
+        data_dict_list: list[dict[str, Any]] = []
+        for user_id, role_ids in data.items():
+            for role_id in role_ids:
+                data_dict_list.append(
+                    self._model_to_data_dict(
+                        UserRole(
+                            id=ulid.new().str,
+                            user_id=user_id,
+                            role_id=role_id,
+                            created_at=now,
+                            created_by=created_by,
+                        )
+                    )
+                )
+        async with self._session_scope() as session:
+            await self._execute_statement(
+                session, insert(UserRole).values(data_dict_list)
+            )
+
+    async def remove_all_roles(self, user_ids: list[str] = []):
+        async with self._session_scope() as session:
+            await self._execute_statement(
+                session,
+                delete(UserRole).where(UserRole.user_id._in(user_ids)),
+            )
+
     async def get_by_credentials(self, username: str, password: str) -> UserResponse:
-        select_statement = self._select().where(
-            User.username == username, User.password == hash_password(password)
+        rows = await self._select_to_response(
+            lambda q: q.where(
+                User.username == username, User.password == hash_password(password)
+            )
         )
-        rows = await self._execute_select_statement(select_statement)
-        responses = self._rows_to_responses(rows)
-        return self._ensure_one(responses)
+        return self._ensure_one(rows)
+
+    async def get_by_token(self, token: str) -> UserResponse:
+        rows = await self._select_tor_response(
+            lambda q: q.where(Session.token == token)
+        )
+        return self._ensure_one(rows)
+
+    async def add_token(self, user_id: str, token: str):
+        async with self._session_scope() as session:
+            await self._execute_statement(
+                session,
+                insert(Session).values(
+                    {
+                        "id": ulid.new().str,
+                        "user_id": user_id,
+                        "token": token,
+                        "created_by": "system",
+                        "created_at": datetime.datetime.now(datetime.timezone.utc),
+                    }
+                ),
+            )
+
+    async def remove_token(self, user_id: str, token: str):
+        async with self._session_scope() as session:
+            await self._execute_statement(
+                session,
+                delete(Session).where(
+                    Session.token == token, Session.user_id == user_id
+                ),
+            )
+
+    async def get_sessions(self, user_id: str) -> list[SessionResponse]:
+        async with self._session_scope() as session:
+            statement = select(Session).where(Session.user_id == user_id)
+            result = await self._execute_statement(session, statement)
+            return [
+                SessionResponse(**session.model_dump())
+                for session in result.scalars().all()
+            ]
+
+    async def remove_session(self, user_id: str, session_id: str) -> SessionResponse:
+        async with self._session_scope() as session:
+            statement = select(Session).where(
+                Session.user_id == user_id, Session.id == session_id
+            )
+            result = await self._execute_statement(session, statement)
+            session = result.scalar_one_or_none()
+            if not session:
+                raise NotFoundError(f"{self.entity_name} not found")
+            await self._execute_statement(
+                session,
+                delete(Session).where(
+                    Session.id == session_id, Session.user_id == user_id
+                ),
+            )
+            return SessionResponse(**session.model_dump())

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/service/user/repository/user_repository.py

@@ -1,5 +1,6 @@
 from abc import ABC, abstractmethod
 
+from my_app_name.schema.session import SessionResponse
 from my_app_name.schema.user import (
     User,
     UserCreateWithAudit,
@@ -18,6 +19,14 @@ class UserRepository(ABC):
     async def get_by_ids(self, id_list: list[str]) -> UserResponse:
         """Get users by ids"""
 
+    @abstractmethod
+    async def add_roles(self, data: dict[str, list[str]], created_by: str):
+        """Add roles to user"""
+
+    @abstractmethod
+    async def remove_all_roles(self, user_ids: list[str] = []):
+        """Remove roles from user"""
+
     @abstractmethod
     async def get(
         self,
@@ -61,3 +70,23 @@ class UserRepository(ABC):
     @abstractmethod
     async def get_by_credentials(self, username: str, password: str) -> UserResponse:
         """Get user by credential"""
+
+    @abstractmethod
+    async def get_by_token(self, token: str) -> UserResponse:
+        """Get user by token"""
+
+    @abstractmethod
+    async def add_token(self, user_id: str, token: str):
+        """Add token to user"""
+
+    @abstractmethod
+    async def remove_token(self, user_id: str, token: str):
+        """Remove token from user"""
+
+    @abstractmethod
+    async def get_sessions(self, user_id: str) -> list[SessionResponse]:
+        """Get sessions"""
+
+    @abstractmethod
+    async def remove_session(self, user_id: str, session_id: str) -> SessionResponse:
+        """Remove a session"""

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/service/user/user_service.py

@@ -6,9 +6,9 @@ from my_app_name.module.auth.service.user.repository.user_repository import (
 )
 from my_app_name.schema.user import (
     MultipleUserResponse,
-    UserCreateWithAudit,
+    UserCreateWithRolesAndAudit,
     UserResponse,
-    UserUpdateWithAudit,
+    UserUpdateWithRolesAndAudit,
 )
 
 
@@ -42,35 +42,57 @@ class UserService(BaseService):
         count = await self.user_repository.count(filter)
         return MultipleUserResponse(data=users, count=count)
 
-    @BaseService.route(
-        "/api/v1/users",
-        methods=["post"],
-        response_model=UserResponse,
-    )
-    async def create_user(self, data: UserCreateWithAudit) -> UserResponse:
-        user = await self.user_repository.create(data)
-        return await self.user_repository.get_by_id(user.id)
-
     @BaseService.route(
         "/api/v1/users/bulk",
         methods=["post"],
         response_model=list[UserResponse],
     )
     async def create_user_bulk(
-        self, data: list[UserCreateWithAudit]
+        self, data: list[UserCreateWithRolesAndAudit]
     ) -> list[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.create_bulk(data)
+        if len(users) > 0:
+            created_by = users[0].created_by
+            await self.user_repository.add_roles(
+                data={user.id: role_ids[i] for i, user in enumerate(data)},
+                created_by=created_by,
+            )
         return await self.user_repository.get_by_ids([user.id for user in users])
 
+    @BaseService.route(
+        "/api/v1/users",
+        methods=["post"],
+        response_model=UserResponse,
+    )
+    async def create_user(self, data: UserCreateWithRolesAndAudit) -> UserResponse:
+        role_ids = data.get_role_ids()
+        data = data.get_user_create_with_audit()
+        user = await self.user_repository.create(data)
+        await self.user_repository.add_roles(
+            data={user.id: role_ids}, created_by=user.created_by
+        )
+        return await self.user_repository.get_by_id(user.id)
+
     @BaseService.route(
         "/api/v1/users/bulk",
         methods=["put"],
         response_model=UserResponse,
     )
     async def update_user_bulk(
-        self, user_ids: list[str], data: UserUpdateWithAudit
+        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])
+            await self.user_repository.add_roles(
+                data={user.id: role_ids[i] for i, user in enumerate(data)},
+                updated_by=updated_by,
+            )
         return await self.user_repository.get_by_ids([user.id for user in users])
 
     @BaseService.route(
@@ -79,7 +101,7 @@ class UserService(BaseService):
         response_model=UserResponse,
     )
     async def update_user(
-        self, user_id: str, data: UserUpdateWithAudit
+        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)

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/gateway/subroute/auth.py

@@ -8,15 +8,15 @@ from my_app_name.schema.permission import (
 )
 from my_app_name.schema.role import (
     MultipleRoleResponse,
-    RoleCreate,
+    RoleCreateWithPermissions,
     RoleResponse,
-    RoleUpdate,
+    RoleUpdateWithPermissions,
 )
 from my_app_name.schema.user import (
     MultipleUserResponse,
-    UserCreate,
+    UserCreateWithRoles,
     UserResponse,
-    UserUpdate,
+    UserUpdateWithRoles,
 )
 
 
@@ -44,7 +44,7 @@ def serve_auth_route(app: FastAPI):
         response_model=list[PermissionResponse],
     )
     async def create_permission_bulk(data: list[PermissionCreate]):
-        return await auth_client.create_permission(
+        return await auth_client.create_permission_bulk(
             [row.with_audit(created_by="system") for row in data]
         )
 
@@ -108,8 +108,8 @@ def serve_auth_route(app: FastAPI):
         "/api/v1/roles/bulk",
         response_model=list[RoleResponse],
     )
-    async def create_role_bulk(data: list[RoleCreate]):
-        return await auth_client.create_role(
+    async def create_role_bulk(data: list[RoleCreateWithPermissions]):
+        return await auth_client.create_role_bulk(
             [row.with_audit(created_by="system") for row in data]
         )
 
@@ -117,14 +117,14 @@ def serve_auth_route(app: FastAPI):
         "/api/v1/roles",
         response_model=RoleResponse,
     )
-    async def create_role(data: RoleCreate):
+    async def create_role(data: RoleCreateWithPermissions):
         return await auth_client.create_role(data.with_audit(created_by="system"))
 
     @app.put(
         "/api/v1/roles/bulk",
         response_model=list[RoleResponse],
     )
-    async def update_role_bulk(role_ids: list[str], data: RoleUpdate):
+    async def update_role_bulk(role_ids: list[str], data: RoleUpdateWithPermissions):
         return await auth_client.update_role_bulk(
             role_ids, data.with_audit(updated_by="system")
         )
@@ -133,7 +133,7 @@ def serve_auth_route(app: FastAPI):
         "/api/v1/roles/{role_id}",
         response_model=RoleResponse,
     )
-    async def update_role(role_id: str, data: RoleUpdate):
+    async def update_role(role_id: str, data: RoleUpdateWithPermissions):
         return await auth_client.update_role(data.with_audit(updated_by="system"))
 
     @app.delete(
@@ -171,7 +171,7 @@ def serve_auth_route(app: FastAPI):
         "/api/v1/users/bulk",
         response_model=list[UserResponse],
     )
-    async def create_user_bulk(data: list[UserCreate]):
+    async def create_user_bulk(data: list[UserCreateWithRoles]):
         return await auth_client.create_user(
             [row.with_audit(created_by="system") for row in data]
         )
@@ -180,14 +180,14 @@ def serve_auth_route(app: FastAPI):
         "/api/v1/users",
         response_model=UserResponse,
     )
-    async def create_user(data: UserCreate):
+    async def create_user(data: UserCreateWithRoles):
         return await auth_client.create_user(data.with_audit(created_by="system"))
 
     @app.put(
         "/api/v1/users/bulk",
         response_model=list[UserResponse],
     )
-    async def update_user_bulk(user_ids: list[str], data: UserUpdate):
+    async def update_user_bulk(user_ids: list[str], data: UserUpdateWithRoles):
         return await auth_client.update_user_bulk(
             user_ids, data.with_audit(updated_by="system")
         )
@@ -196,7 +196,7 @@ def serve_auth_route(app: FastAPI):
         "/api/v1/users/{user_id}",
         response_model=UserResponse,
     )
-    async def update_user(user_id: str, data: UserUpdate):
+    async def update_user(user_id: str, data: UserUpdateWithRoles):
         return await auth_client.update_user(data.with_audit(updated_by="system"))
 
     @app.delete(

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/schema/permission.py

@@ -47,5 +47,5 @@ class Permission(SQLModel, table=True):
     created_by: str | None = Field(index=True)
     updated_at: datetime.datetime | None = Field(index=True)
     updated_by: str | None = Field(index=True)
-    name: str = Field(index=True)
+    name: str = Field(index=True, unique=True)
     description: str

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/schema/role.py

@@ -22,7 +22,7 @@ class RoleCreateWithAudit(RoleCreate):
 
 
 class RoleCreateWithPermissions(RoleCreate):
-    permissions: list[str] | None = None
+    permission_ids: list[str] | None = None
 
     def with_audit(self, created_by: str) -> "RoleCreateWithPermissionsAndAudit":
         return RoleCreateWithPermissionsAndAudit(
@@ -35,14 +35,16 @@ class RoleCreateWithPermissionsAndAudit(RoleCreateWithPermissions):
 
     def get_role_create_with_audit(self) -> RoleCreateWithAudit:
         data = {
-            key: val for key, val in self.model_dump().items() if key != "permissions"
+            key: val
+            for key, val in self.model_dump().items()
+            if key != "permission_ids"
         }
         return RoleCreateWithAudit(**data)
 
-    def get_permission_names(self) -> list[str]:
-        if self.permissions is None:
+    def get_permission_ids(self) -> list[str]:
+        if self.permission_ids is None:
             return []
-        return self.permissions
+        return self.permission_ids
 
 
 class RoleUpdate(SQLModel):
@@ -57,6 +59,32 @@ class RoleUpdateWithAudit(RoleUpdate):
     updated_by: str
 
 
+class RoleUpdateWithPermissions(RoleUpdate):
+    permission_ids: list[str] | None = None
+
+    def with_audit(self, updated_by: str) -> "RoleUpdateWithPermissionsAndAudit":
+        return RoleUpdateWithPermissionsAndAudit(
+            **self.model_dump(), updated_by=updated_by
+        )
+
+
+class RoleUpdateWithPermissionsAndAudit(RoleUpdateWithPermissions):
+    updated_by: str
+
+    def get_role_update_with_audit(self) -> RoleUpdateWithAudit:
+        data = {
+            key: val
+            for key, val in self.model_dump().items()
+            if key != "permission_ids"
+        }
+        return RoleUpdateWithAudit(**data)
+
+    def get_permission_ids(self) -> list[str]:
+        if self.permission_ids is None:
+            return []
+        return self.permission_ids
+
+
 class RoleResponse(RoleBase):
     id: str
     permissions: list[Permission]
@@ -73,7 +101,7 @@ class Role(SQLModel, table=True):
     created_by: str | None = Field(index=True)
     updated_at: datetime.datetime | None = Field(index=True)
     updated_by: str | None = Field(index=True)
-    name: str = Field(index=True)
+    name: str = Field(index=True, unique=True)
     description: str
 
 

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/schema/session.py

@@ -7,9 +7,7 @@ from sqlmodel import Field, SQLModel
 
 class SessionBase(SQLModel):
     user_id: str
-    device: str
-    os: str
-    browser: str
+    token: str
     expired_at: datetime.datetime | None
 
 
@@ -47,6 +45,4 @@ class MultipleSessionResponse(BaseModel):
 class Session(SQLModel, table=True):
     id: str = Field(default_factory=lambda: ulid.new().str, primary_key=True)
     user_id: str = Field(index=True)
-    device: str
-    os: str
-    browser: str
+    token: str = Field(index=True, unique=True)

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/schema/user.py

@@ -13,7 +13,6 @@ class UserBase(SQLModel):
 
 class UserCreate(UserBase):
     password: str
-    roles: list[str] | None = None
 
     def with_audit(self, created_by: str) -> "UserCreateWithAudit":
         return UserCreateWithAudit(**self.model_dump(), created_by=created_by)
@@ -23,6 +22,26 @@ class UserCreateWithAudit(UserCreate):
     created_by: str
 
 
+class UserCreateWithRoles(UserCreate):
+    role_ids: list[str] | None = None
+
+    def with_audit(self, created_by: str) -> "UserCreateWithRolesAndAudit":
+        return UserCreateWithRolesAndAudit(**self.model_dump(), created_by=created_by)
+
+
+class UserCreateWithRolesAndAudit(UserCreateWithRoles):
+    created_by: str
+
+    def get_user_create_with_audit(self) -> UserCreateWithAudit:
+        data = {key: val for key, val in self.model_dump().items() if key != "role_ids"}
+        return UserCreateWithAudit(**data)
+
+    def get_role_ids(self) -> list[str]:
+        if self.role_ids is None:
+            return []
+        return self.role_ids
+
+
 class UserUpdate(SQLModel):
     username: str | None = None
     password: str | None = None
@@ -35,6 +54,26 @@ class UserUpdateWithAudit(UserUpdate):
     updated_by: str
 
 
+class UserUpdateWithRoles(UserUpdate):
+    role_ids: list[str] | None = None
+
+    def with_audit(self, updated_by: str) -> "UserUpdateWithRolesAndAudit":
+        return UserUpdateWithRolesAndAudit(**self.model_dump(), updated_by=updated_by)
+
+
+class UserUpdateWithRolesAndAudit(UserUpdateWithRoles):
+    updated_by: str
+
+    def get_user_update_with_audit(self) -> UserUpdateWithAudit:
+        data = {key: val for key, val in self.model_dump().items() if key != "role_ids"}
+        return UserUpdateWithAudit(**data)
+
+    def get_role_ids(self) -> list[str]:
+        if self.role_ids is None:
+            return []
+        return self.role_ids
+
+
 class UserResponse(UserBase):
     id: str
     roles: list[Role]
@@ -52,7 +91,7 @@ class User(SQLModel, table=True):
     created_by: str = Field(index=True)
     updated_at: datetime.datetime | None = Field(index=True)
     updated_by: str | None = Field(index=True)
-    username: str = Field(index=True)
+    username: str = Field(index=True, unique=True)
     password: str
 
 

zrb/builtin/todo.py

@@ -294,6 +294,7 @@ def _get_default_stop_work_time_str() -> str:
             description="Todo.txt content",
             prompt="Todo.txt content (will override existing)",
             default_str=lambda _: _get_todo_txt_content(),
+            allow_positional_parsing=False,
         ),
     ],
     description="📝 Edit todo",

zrb/config.py

@@ -77,13 +77,32 @@ WEB_AUTH_REFRESH_TOKEN_EXPIRE_MINUTES = int(
     os.getenv("ZRB_WEB_REFRESH_TOKEN_EXPIRE_MINUTES", "60")
 )
 LLM_MODEL = os.getenv("ZRB_LLM_MODEL", "ollama_chat/llama3.1")
-LLM_SYSTEM_PROMPT = os.getenv("ZRB_LLM_SYSTEM_PROMPT", "You are a helpful assistant")
+
+_DEFAULT_PROMPT = """
+You are a helpful assistant and you have access to several tools.
+Your goal is to provide a final answer by executing a series of planning, actions, reasoning, and evaluations.
+
+Breakdown user request into several actionable tasks. For example, when user ask about current weather on current location, you should get the current location first.
+
+DO NOT TRY TO SIMULATE TOOL OUTPUT.
+
+ERROR HANDLING
+1. If you receive an error, read the error message carefully and identify the specific issue.
+2. Adjust your response accordingly and perform the review process again before resubmitting.
+
+REMINDER:
+- ALWAYS double-check your response format and function arguments before submitting.
+- DON'T make up answers.
+""".strip()
+LLM_SYSTEM_PROMPT = os.getenv("ZRB_LLM_SYSTEM_PROMPT", _DEFAULT_PROMPT)
+LLM_HISTORY_DIR = os.getenv(
+    "ZRB_LLM_HISTORY_DIR", os.path.expanduser(os.path.join("~", ".zrb-llm-history"))
+)
 LLM_HISTORY_FILE = os.getenv(
-    "ZRB_LLM_HISTORY_FILE",
-    os.path.expanduser(os.path.join("~", ".zrb-llm-history.json")),
+    "ZRB_LLM_HISTORY_FILE", os.path.join(LLM_HISTORY_DIR, "history.json")
 )
 LLM_ALLOW_ACCESS_SHELL = to_boolean(os.getenv("ZRB_LLM_ACCESS_FILE", "1"))
-LLM_ALLOW_ACCESS_WEB = to_boolean(os.getenv("ZRB_LLM_ACCESS_WEB", "1"))
+LLM_ALLOW_ACCESS_INTERNET = to_boolean(os.getenv("ZRB_LLM_ACCESS_INTERNET", "1"))
 RAG_EMBEDDING_MODEL = os.getenv("ZRB_RAG_EMBEDDING_MODEL", "ollama/nomic-embed-text")
 RAG_CHUNK_SIZE = int(os.getenv("ZRB_RAG_CHUNK_SIZE", "1024"))
 RAG_OVERLAP = int(os.getenv("ZRB_RAG_OVERLAP", "128"))

zrb/input/any_input.py

@@ -19,6 +19,11 @@ class AnyInput(ABC):
     def prompt_message(self) -> str:
         pass
 
+    @property
+    @abstractmethod
+    def allow_positional_parsing(self) -> bool:
+        pass
+
     @abstractmethod
     def to_html(self, shared_ctx: AnySharedContext) -> str:
         pass