zrb 1.0.0a2__py3-none-any.whl → 1.0.0a4__py3-none-any.whl

zrb/env/env_map.py

@@ -1,8 +1,8 @@
 import os
 from collections.abc import Callable
 
-from ..context.shared_context import SharedContext
-from .any_env import AnyEnv
+from zrb.context.shared_context import SharedContext
+from zrb.env.any_env import AnyEnv
 
 
 class EnvMap(AnyEnv):

zrb/group/__init__.py

@@ -1,3 +0,0 @@
-from .group import Group
-
-assert Group

zrb/group/any_group.py

@@ -1,7 +1,7 @@
 from abc import ABC, abstractmethod
-from typing import Optional
+from typing import Optional, Union
 
-from ..task.any_task import AnyTask
+from zrb.task.any_task import AnyTask
 
 
 class AnyGroup(ABC):
@@ -36,7 +36,7 @@ class AnyGroup(ABC):
         pass
 
     @abstractmethod
-    def add_group(self, group: "AnyGroup") -> "AnyGroup":
+    def add_group(self, group: Union["AnyGroup", str]) -> "AnyGroup":
         pass
 
     @abstractmethod

zrb/group/group.py

@@ -1,5 +1,5 @@
-from ..task.any_task import AnyTask
-from .any_group import AnyGroup
+from zrb.group.any_group import AnyGroup
+from zrb.task.any_task import AnyTask
 
 
 class Group(AnyGroup):
@@ -42,10 +42,11 @@ class Group(AnyGroup):
         alias.sort()
         return {name: self._tasks.get(name) for name in alias}
 
-    def add_group(self, group: AnyGroup, alias: str | None = None) -> AnyGroup:
-        alias = alias if alias is not None else group.name
-        self._groups[alias] = group
-        return group
+    def add_group(self, group: AnyGroup | str, alias: str | None = None) -> AnyGroup:
+        real_group = Group(group) if isinstance(group, str) else group
+        alias = alias if alias is not None else real_group.name
+        self._groups[alias] = real_group
+        return real_group
 
     def add_task(self, task: AnyTask, alias: str | None = None) -> AnyTask:
         alias = alias if alias is not None else task.name

zrb/input/any_input.py

@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod
 
-from ..context.any_shared_context import AnySharedContext
+from zrb.context.any_shared_context import AnySharedContext
 
 
 class AnyInput(ABC):

zrb/input/base_input.py

@@ -1,9 +1,9 @@
 from typing import Any
 
-from ..attr.type import StrAttr
-from ..context.any_shared_context import AnySharedContext
-from ..util.attr import get_str_attr
-from .any_input import AnyInput
+from zrb.attr.type import StrAttr
+from zrb.context.any_shared_context import AnySharedContext
+from zrb.input.any_input import AnyInput
+from zrb.util.attr import get_str_attr
 
 
 class BaseInput(AnyInput):

zrb/input/bool_input.py

@@ -1,10 +1,10 @@
-from ..attr.type import StrAttr
-from ..context.any_shared_context import AnySharedContext
-from ..util.string.conversion import to_boolean
-from .base_input import BaseInput
+from zrb.attr.type import StrAttr
+from zrb.context.any_shared_context import AnySharedContext
+from zrb.input.base_input import BaseInput
+from zrb.util.string.conversion import to_boolean
 
 
-class IntInput(BaseInput):
+class BoolInput(BaseInput):
     def __init__(
         self,
         name: str,

zrb/input/float_input.py

@@ -1,6 +1,6 @@
-from ..attr.type import StrAttr
-from ..context.any_shared_context import AnySharedContext
-from .base_input import BaseInput
+from zrb.attr.type import StrAttr
+from zrb.context.any_shared_context import AnySharedContext
+from zrb.input.base_input import BaseInput
 
 
 class FloatInput(BaseInput):

zrb/input/int_input.py

@@ -1,6 +1,6 @@
-from ..attr.type import StrAttr
-from ..context.any_shared_context import AnySharedContext
-from .base_input import BaseInput
+from zrb.attr.type import StrAttr
+from zrb.context.any_shared_context import AnySharedContext
+from zrb.input.base_input import BaseInput
 
 
 class IntInput(BaseInput):

zrb/input/option_input.py

@@ -0,0 +1,51 @@
+from zrb.attr.type import StrAttr, StrListAttr
+from zrb.context.any_shared_context import AnySharedContext
+from zrb.input.base_input import BaseInput
+from zrb.util.attr import get_str_list_attr
+
+
+class OptionInput(BaseInput):
+    def __init__(
+        self,
+        name: str,
+        description: str | None = None,
+        prompt: str | None = None,
+        options: StrListAttr = [],
+        default_str: StrAttr = "",
+        auto_render: bool = True,
+        allow_empty: bool = True,
+    ):
+        super().__init__(
+            name=name,
+            description=description,
+            prompt=prompt,
+            default_str=default_str,
+            auto_render=auto_render,
+            allow_empty=allow_empty,
+        )
+        self._options = options
+
+    def to_html(self, ctx: AnySharedContext) -> str:
+        name = self.name
+        description = self.description
+        default = self._get_default_str(ctx)
+        html = [f'<select name="{name}" placeholder="{description}">']
+        for value in get_str_list_attr(ctx, self._options, self._auto_render):
+            selected = "selected" if value == default else ""
+            html.append(f'<option value="{value}" {selected}>{value}</option>')
+        html.append("</select>")
+        return "\n".join(html)
+
+    def _prompt_cli_str(self, shared_ctx: AnySharedContext) -> str:
+        prompt_message = self.prompt_message
+        default_value = self._get_default_str(shared_ctx)
+        options = get_str_list_attr(shared_ctx, self._options, self._auto_render)
+        option_str = ", ".join(options)
+        if default_value != "":
+            prompt_message = f"{prompt_message} ({option_str}) [{default_value}]"
+        value = input(f"{prompt_message}: ")
+        if value.strip() != "" and value.strip() not in options:
+            value = self._prompt_cli_str(shared_ctx)
+        if value.strip() == "":
+            value = default_value
+        return value

zrb/input/password_input.py

@@ -1,8 +1,8 @@
 import getpass
 from collections.abc import Callable
 
-from ..context.any_shared_context import AnySharedContext
-from .base_input import BaseInput
+from zrb.context.any_shared_context import AnySharedContext
+from zrb.input.base_input import BaseInput
 
 
 class PasswordInput(BaseInput):

zrb/input/str_input.py

@@ -1,4 +1,4 @@
-from .base_input import BaseInput
+from zrb.input.base_input import BaseInput
 
 
 class StrInput(BaseInput):

zrb/input/text_input.py

@@ -1,10 +1,11 @@
+import os
 import subprocess
 import tempfile
 from collections.abc import Callable
 
-from ..config import DEFAULT_EDITOR
-from ..context.any_shared_context import AnySharedContext
-from .base_input import BaseInput
+from zrb.config import DEFAULT_EDITOR
+from zrb.context.any_shared_context import AnySharedContext
+from zrb.input.base_input import BaseInput
 
 
 class TextInput(BaseInput):
@@ -66,14 +67,15 @@ class TextInput(BaseInput):
 
     def _prompt_cli_str(self, shared_ctx: AnySharedContext) -> str:
         prompt_message = (
-            f"{self.comment_start}{super().prompt_message}{self.comment_end}\n"
+            f"{self.comment_start}{super().prompt_message}{self.comment_end}"
         )
+        prompt_message_eol = f"{prompt_message}\n"
         default_value = self._get_default_str(shared_ctx)
         with tempfile.NamedTemporaryFile(
             delete=False, suffix=self._extension
         ) as temp_file:
             temp_file_name = temp_file.name
-            temp_file.write(prompt_message.encode())
+            temp_file.write(prompt_message_eol.encode())
             # Pre-fill with default content
             if default_value:
                 temp_file.write(default_value.encode())
@@ -82,8 +84,8 @@ class TextInput(BaseInput):
         subprocess.call([self._editor, temp_file_name])
         # Read the edited content
         with open(temp_file_name, "r") as temp_file:
-            edited_content = temp_file.read().strip()
-            parts = edited_content.split(prompt_message)
-            if len(parts) == 2 and parts[0].strip() == "":
-                edited_content = parts[1]
-        return edited_content.strip() if edited_content.strip() else default_value
+            edited_content = temp_file.read()
+            parts = [text.strip() for text in edited_content.split(prompt_message, 1)]
+            edited_content = "\n".join(parts).lstrip()
+        os.remove(temp_file_name)
+        return edited_content

zrb/runner/cli.py

@@ -1,16 +1,22 @@
 import sys
 from typing import Any
 
-from ..config import BANNER, WEB_HTTP_PORT
-from ..context.shared_context import SharedContext
-from ..group.group import Group
-from ..session.session import Session
-from ..task.any_task import AnyTask
-from ..task.task import Task
-from ..util.cli.style import stylize_bold_yellow, stylize_faint, stylize_section_header
-from ..util.group import extract_node_from_args, get_non_empty_subgroups, get_subtasks
-from ..util.load import load_zrb_init
-from .web_server import run_web_server
+from zrb.config import BANNER, WEB_HTTP_PORT
+from zrb.context.any_context import AnyContext
+from zrb.context.shared_context import SharedContext
+from zrb.group.group import Group
+from zrb.runner.web_app import create_app
+from zrb.session.session import Session
+from zrb.task.any_task import AnyTask
+from zrb.task.make_task import make_task
+from zrb.util.cli.style import (
+    stylize_bold_yellow,
+    stylize_faint,
+    stylize_section_header,
+)
+from zrb.util.group import extract_node_from_args, get_non_empty_subgroups, get_subtasks
+from zrb.util.load import load_zrb_init
+from zrb.util.string.conversion import double_quote
 
 
 class Cli(Group):
@@ -25,12 +31,15 @@ class Cli(Group):
         if "h" in kwargs or "help" in kwargs:
             self._show_task_info(node)
             return
-        result = self._run_task(node, args, kwargs)
-        if result is not None:
-            print(result)
-        run_command = self._get_run_command(node_path, kwargs, args)
-        self._print_run_command(run_command)
-        return result
+        run_kwargs = self._get_run_kwargs(node, args, kwargs)
+        try:
+            result = self._run_task(node, args, run_kwargs)
+            if result is not None:
+                print(result)
+            return result
+        finally:
+            run_command = self._get_run_command(node_path, run_kwargs)
+            self._print_run_command(run_command)
 
     def _print_run_command(self, run_command: str):
         print(
@@ -39,34 +48,48 @@ class Cli(Group):
             file=sys.stderr,
         )
 
-    def _get_run_command(
-        self, node_path: list[str], kwargs: dict[str, Any], args: list[str]
-    ) -> str:
+    def _get_run_command(self, node_path: list[str], run_kwargs: dict[str, str]) -> str:
         parts = [self.name] + node_path
-        if len(kwargs) > 0:
-            parts += [f"--{key}={val}" for key, val in kwargs.items()]
-        if len(args) > 0:
-            parts += args
+        if len(run_kwargs) > 0:
+            parts += [
+                self._get_run_command_param(key, val) for key, val in run_kwargs.items()
+            ]
         return " ".join(parts)
 
-    def _run_task(self, task: AnyTask, args: list[str], options: list[str]) -> Any:
+    def _get_run_command_param(self, key: str, val: str) -> str:
+        if '"' in val or "'" in val or " " in val or val == "":
+            return f"--{key} {double_quote(val)}"
+        return f"--{key} {val}"
+
+    def _run_task(
+        self, task: AnyTask, args: list[str], run_kwargs: dict[str, str]
+    ) -> tuple[Any]:
+        shared_ctx = SharedContext(args=args)
+        for task_input in task.inputs:
+            if task_input.name in run_kwargs:
+                task_input.update_shared_context(
+                    shared_ctx, run_kwargs[task_input.name]
+                )
+                continue
+        return task.run(Session(shared_ctx=shared_ctx, root_group=self))
+
+    def _get_run_kwargs(
+        self, task: AnyTask, args: list[str], kwargs: dict[str, str]
+    ) -> tuple[Any]:
         arg_index = 0
-        str_kwargs = {key: val for key, val in options.items()}
+        str_kwargs = {key: val for key, val in kwargs.items()}
+        run_kwargs = {**str_kwargs}
         shared_ctx = SharedContext(args=args)
         for task_input in task.inputs:
             if task_input.name in str_kwargs:
                 continue
             if arg_index < len(args):
-                str_kwargs[task_input.name] = args[arg_index]
+                run_kwargs[task_input.name] = args[arg_index]
                 arg_index += 1
                 continue
-            str_kwargs[task_input.name] = task_input.prompt_cli_str(shared_ctx)
-        try:
-            return task.run(
-                Session(shared_ctx=shared_ctx, root_group=self), str_kwargs=str_kwargs
-            )
-        except KeyboardInterrupt:
-            pass
+            str_value = task_input.prompt_cli_str(shared_ctx)
+            run_kwargs[task_input.name] = str_value
+        return run_kwargs
 
     def _show_task_info(self, task: AnyTask):
         description = task.description
@@ -77,8 +100,9 @@ class Cli(Group):
             print()
         if len(inputs) > 0:
             print(stylize_section_header("INPUTS"))
+            max_input_name_length = max(len(task_input.name) for task_input in inputs)
             for task_input in inputs:
-                task_input_name = task_input.name.ljust(20)
+                task_input_name = task_input.name.ljust(max_input_name_length + 1)
                 print(f"  --{task_input_name}: {task_input.description}")
             print()
 
@@ -93,15 +117,17 @@ class Cli(Group):
         subgroups = get_non_empty_subgroups(group)
         if len(subgroups) > 0:
             print(stylize_section_header("GROUPS"))
+            max_subgroup_alias_length = max(len(s) for s in subgroups)
             for alias, subgroup in subgroups.items():
-                alias = alias.ljust(20)
+                alias = alias.ljust(max_subgroup_alias_length + 1)
                 print(f"  {alias}: {subgroup.description}")
             print()
         subtasks = get_subtasks(group)
         if len(subtasks) > 0:
             print(stylize_section_header("TASKS"))
+            max_subtask_alias_length = max(len(s) for s in subtasks)
             for alias, subtask in subtasks.items():
-                alias = alias.ljust(20)
+                alias = alias.ljust(max_subtask_alias_length + 1)
                 print(f"  {alias}: {subtask.description}")
             print()
 
@@ -139,14 +165,23 @@ class Cli(Group):
 
 
 cli = Cli(name="zrb", description="Your Automation Powerhouse", banner=BANNER)
-server = cli.add_group(Group(name="server", description="Server related command"))
-server.add_task(
-    Task(
-        name="start-server",
-        description="Make tasks available via HTTP Requests 🚀",
-        action=lambda ctx: run_web_server(ctx=ctx, root_group=cli, port=WEB_HTTP_PORT),
-        cli_only=True,
-        retries=0,
-    ),
+server_group = cli.add_group(
+    Group(name="server", description="🌐 Server related command")
+)
+
+
+@make_task(
+    name="start-server",
+    description="🚀 Start Zrb Web Server",
+    cli_only=True,
+    retries=0,
+    group=server_group,
     alias="start",
 )
+async def run(_: AnyContext):
+    from uvicorn import Config, Server
+
+    app = create_app(cli, WEB_HTTP_PORT)
+    config = Config(app=app, host="0.0.0.0", port=WEB_HTTP_PORT, loop="asyncio")
+    server = Server(config)
+    await server.serve()

zrb/runner/web_app.py

@@ -0,0 +1,150 @@
+import asyncio
+import os
+import sys
+from datetime import datetime, timedelta
+from typing import Any, Dict, List
+
+from zrb.config import BANNER, WEB_HTTP_PORT
+from zrb.context.shared_context import SharedContext
+from zrb.group.any_group import AnyGroup
+from zrb.runner.web_controller.group_info_ui.controller import handle_group_info_ui
+from zrb.runner.web_controller.home_page.controller import handle_home_page
+from zrb.runner.web_controller.task_ui.controller import handle_task_ui
+from zrb.runner.web_util import NewSessionResponse
+from zrb.session.session import Session
+from zrb.session_state_log.session_state_log import SessionStateLog, SessionStateLogList
+from zrb.session_state_logger.default_session_state_logger import (
+    default_session_state_logger,
+)
+from zrb.task.any_task import AnyTask
+from zrb.util.group import extract_node_from_args, get_node_path
+
+
+def create_app(root_group: AnyGroup, port: int = WEB_HTTP_PORT):
+    from contextlib import asynccontextmanager
+
+    from fastapi import FastAPI, HTTPException, Request
+    from fastapi.responses import FileResponse, HTMLResponse
+    from fastapi.staticfiles import StaticFiles
+
+    _STATIC_DIR = os.path.join(os.path.dirname(__file__), "web_app", "static")
+    _COROS = []
+
+    @asynccontextmanager
+    async def lifespan(app: FastAPI):
+        for line in BANNER.split("\n") + [
+            f"Zrb Server running on http://localhost:{port}"
+        ]:
+            print(line, file=sys.stderr)
+        yield
+        for coro in _COROS:
+            coro.cancel()
+        asyncio.gather(*_COROS)
+
+    app = FastAPI(title="zrb", lifespan=lifespan)
+
+    # Serve static files
+    app.mount("/static", StaticFiles(directory=_STATIC_DIR), name="static")
+
+    @app.get("/", response_class=HTMLResponse, include_in_schema=False)
+    @app.get("/ui", response_class=HTMLResponse, include_in_schema=False)
+    @app.get("/ui/", response_class=HTMLResponse, include_in_schema=False)
+    async def home_page():
+        return handle_home_page(root_group)
+
+    @app.get("/static/{file_path:path}", include_in_schema=False)
+    async def static_files(file_path: str):
+        full_path = os.path.join(_STATIC_DIR, file_path)
+        if os.path.isfile(full_path):
+            return FileResponse(full_path)
+        raise HTTPException(status_code=404, detail="File not found")
+
+    @app.get("/ui/{path:path}", include_in_schema=False)
+    async def ui_page(path: str):
+        # Avoid capturing '/ui' itself
+        if not path:
+            raise HTTPException(status_code=404, detail="Not Found")
+        args = path.split("/")
+        node, node_path, residual_args = extract_node_from_args(root_group, args)
+        url = f"/ui/{'/'.join(node_path)}/"
+        if isinstance(node, AnyTask):
+            shared_ctx = SharedContext(env=dict(os.environ))
+            session = Session(shared_ctx=shared_ctx, root_group=root_group)
+            return handle_task_ui(root_group, node, session, url, residual_args)
+        elif isinstance(node, AnyGroup):
+            return handle_group_info_ui(root_group, node, url)
+        raise HTTPException(status_code=404, detail="Not Found")
+
+    @app.post("/api/{path:path}")
+    async def create_new_session(
+        path: str, request: Request = None
+    ) -> NewSessionResponse:
+        """
+        Creating new session
+        """
+        args = path.split("/")
+        node, _, residual_args = extract_node_from_args(root_group, args)
+        if isinstance(node, AnyTask):
+            session_name = residual_args[0] if residual_args else None
+            if not session_name:
+                body = await request.json()
+                shared_ctx = SharedContext(env=dict(os.environ))
+                session = Session(shared_ctx=shared_ctx, root_group=root_group)
+                coro = asyncio.create_task(node.async_run(session, str_kwargs=body))
+                _COROS.append(coro)
+                coro.add_done_callback(lambda coro: _COROS.remove(coro))
+                return NewSessionResponse(session_name=session.name)
+        raise HTTPException(status_code=404, detail="Not Found")
+
+    @app.get("/api/{path:path}", response_model=SessionStateLog | SessionStateLogList)
+    async def get_session(path: str, query_params: Dict[str, Any] = {}):
+        """
+        Getting existing session or sessions
+        """
+        args = path.split("/")
+        node, _, residual_args = extract_node_from_args(root_group, args)
+        if isinstance(node, AnyTask) and residual_args:
+            if residual_args[0] == "list":
+                task_path = get_node_path(root_group, node)
+                return list_sessions(task_path, query_params)
+            else:
+                return read_session(residual_args[0])
+        raise HTTPException(status_code=404, detail="Not Found")
+
+    def list_sessions(
+        task_path: List[str], query_params: Dict[str, Any]
+    ) -> SessionStateLogList:
+        max_start_time = datetime.now()
+        if "to" in query_params:
+            max_start_time = datetime.strptime(query_params["to"], "%Y-%m-%d %H:%M:%S")
+        min_start_time = max_start_time - timedelta(hours=1)
+        if "from" in query_params:
+            min_start_time = datetime.strptime(
+                query_params["from"], "%Y-%m-%d %H:%M:%S"
+            )
+        page = int(query_params.get("page", 0))
+        limit = int(query_params.get("limit", 10))
+        try:
+            return default_session_state_logger.list(
+                task_path,
+                min_start_time=min_start_time,
+                max_start_time=max_start_time,
+                page=page,
+                limit=limit,
+            )
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=str(e))
+
+    def read_session(session_name: str) -> SessionStateLog:
+        try:
+            return default_session_state_logger.read(session_name)
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=str(e))
+
+    return app
+
+
+# async def run_web_server(app: FastAPI, port: int = WEB_HTTP_PORT):
+#     config = Config(app=app, host="0.0.0.0", port=port, loop="asyncio")
+#     server = Server(config)
+#     await server.serve()

zrb/runner/{web_app → web_controller}/group_info_ui/controller.py

@@ -1,9 +1,8 @@
 import os
 
-from ....group.any_group import AnyGroup
-from ....util.group import get_non_empty_subgroups, get_subtasks
-from ....util.string.format import fstring_format
-from ..any_request_handler import AnyRequestHandler
+from zrb.group.any_group import AnyGroup
+from zrb.util.group import get_non_empty_subgroups, get_subtasks
+from zrb.util.string.format import fstring_format
 
 _DIR = os.path.dirname(__file__)
 
@@ -23,9 +22,9 @@ with open(os.path.join(_DIR, "partial", "task_li.html")) as f:
     _TASK_LI_TEMPLATE = f.read()
 
 
-def handle_group_info_ui(
-    handler: AnyRequestHandler, root_group: AnyGroup, group: AnyGroup, url: str
-):
+def handle_group_info_ui(root_group: AnyGroup, group: AnyGroup, url: str):
+    from fastapi.responses import HTMLResponse
+
     url_parts = url.split("/")
     parent_url_parts = url_parts[:-2] + [""]
     parent_url = "/".join(parent_url_parts)
@@ -75,7 +74,7 @@ def handle_group_info_ui(
             },
         )
     )
-    handler.send_html_response(
+    return HTMLResponse(
         fstring_format(
             _VIEW_TEMPLATE,
             {

zrb/runner/{web_app → web_controller}/group_info_ui/view.html

@@ -4,8 +4,8 @@
     <meta charset="utf-8">
     <meta name="viewport" content="width=device-width, initial-scale=1">
     <meta name="color-scheme" content="light dark">
-    <link rel="stylesheet" href="/pico.min.css">
-    <link rel="icon" href="/favicon-32x32.png" sizes="32x32" type="image/png">
+    <link rel="stylesheet" href="/static/pico.min.css">
+    <link rel="icon" href="/static/favicon-32x32.png" sizes="32x32" type="image/png">
     <title>Zrb</title>
   </head>
   <body>

zrb/runner/{web_app → web_controller}/home_page/controller.py

@@ -1,9 +1,8 @@
 import os
 
-from ....group.any_group import AnyGroup
-from ....util.group import get_non_empty_subgroups, get_subtasks
-from ....util.string.format import fstring_format
-from ..any_request_handler import AnyRequestHandler
+from zrb.group.any_group import AnyGroup
+from zrb.util.group import get_non_empty_subgroups, get_subtasks
+from zrb.util.string.format import fstring_format
 
 _DIR = os.path.dirname(__file__)
 
@@ -23,7 +22,9 @@ with open(os.path.join(_DIR, "partial", "task_li.html")) as f:
     _TASK_LI_TEMPLATE = f.read()
 
 
-def handle_home_page(handler: AnyRequestHandler, root_group: AnyGroup):
+def handle_home_page(root_group: AnyGroup):
+    from fastapi.responses import HTMLResponse
+
     subgroups = get_non_empty_subgroups(root_group, web_only=True)
     group_info = (
         ""
@@ -62,7 +63,7 @@ def handle_home_page(handler: AnyRequestHandler, root_group: AnyGroup):
             },
         )
     )
-    handler.send_html_response(
+    return HTMLResponse(
         fstring_format(
             _VIEW_TEMPLATE,
             {