zrb 0.28.1__py3-none-any.whl → 1.0.0a8__py3-none-any.whl

zrb/runner/cli.py

@@ -0,0 +1,187 @@
+import sys
+from typing import Any
+
+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):
+
+    def run(self, args: list[str] = []):
+        load_zrb_init()
+        kwargs, args = self._extract_kwargs_from_args(args)
+        node, node_path, args = extract_node_from_args(self, args)
+        if isinstance(node, Group):
+            self._show_group_info(node)
+            return
+        if "h" in kwargs or "help" in kwargs:
+            self._show_task_info(node)
+            return
+        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(
+            stylize_faint("To run again:"),
+            stylize_bold_yellow(run_command),
+            file=sys.stderr,
+        )
+
+    def _get_run_command(self, node_path: list[str], run_kwargs: dict[str, str]) -> str:
+        parts = [self.name] + node_path
+        if len(run_kwargs) > 0:
+            parts += [
+                self._get_run_command_param(key, val) for key, val in run_kwargs.items()
+            ]
+        return " ".join(parts)
+
+    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 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):
+                run_kwargs[task_input.name] = args[arg_index]
+                arg_index += 1
+                continue
+            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
+        inputs = task.inputs
+        if description != task.name and description != "":
+            print(stylize_section_header("DESCRIPTION"))
+            print(description)
+            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(max_input_name_length + 1)
+                print(f"  --{task_input_name}: {task_input.description}")
+            print()
+
+    def _show_group_info(self, group: Group):
+        if group.banner != "":
+            print(group.banner)
+            print()
+        if group.description != group.name and group.description != "":
+            print(stylize_section_header("DESCRIPTION"))
+            print(group.description)
+            print()
+        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(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(max_subtask_alias_length + 1)
+                print(f"  {alias}: {subtask.description}")
+            print()
+
+    def _extract_kwargs_from_args(
+        self, args: list[str]
+    ) -> tuple[dict[str, Any], list[str]]:
+        residual_args = []  # To store positional arguments
+        kwargs = {}  # To store options as a dictionary
+        i = 0
+        while i < len(args):
+            arg = args[i]
+            if arg.startswith("--"):
+                # Handle key-value pairs like --keyword=value
+                if "=" in arg:
+                    key, value = arg[2:].split("=", 1)
+                    kwargs[key] = value
+                else:
+                    # Handle flags like --this followed by a value or set to True
+                    key = arg[2:]
+                    # Check if the next item is a value or another flag
+                    if i + 1 < len(args) and not args[i + 1].startswith("-"):
+                        kwargs[key] = args[i + 1]
+                        i += 1  # Skip the next argument as it's a value
+                    else:
+                        kwargs[key] = True
+            elif arg.startswith("-"):
+                # Handle short flags like -t or -n
+                key = arg[1:]
+                kwargs[key] = True
+            else:
+                # Anything else is considered a positional argument
+                residual_args.append(arg)
+            i += 1
+        return kwargs, residual_args
+
+
+cli = Cli(name="zrb", description="Your Automation Powerhouse", banner=BANNER)
+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,144 @@
+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_controller", "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

zrb/runner/web_controller/group_info_ui/controller.py

@@ -0,0 +1,91 @@
+import os
+
+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__)
+
+with open(os.path.join(_DIR, "view.html"), "r") as f:
+    _VIEW_TEMPLATE = f.read()
+
+with open(os.path.join(_DIR, "partial", "group_info.html")) as f:
+    _GROUP_INFO_TEMPLATE = f.read()
+
+with open(os.path.join(_DIR, "partial", "group_li.html")) as f:
+    _GROUP_LI_TEMPLATE = f.read()
+
+with open(os.path.join(_DIR, "partial", "task_info.html")) as f:
+    _TASK_INFO_TEMPLATE = f.read()
+
+with open(os.path.join(_DIR, "partial", "task_li.html")) as f:
+    _TASK_LI_TEMPLATE = f.read()
+
+
+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)
+    subgroups = get_non_empty_subgroups(group, web_only=True)
+    group_info = (
+        ""
+        if len(subgroups) == 0
+        else fstring_format(
+            _GROUP_INFO_TEMPLATE,
+            {
+                "group_li": "\n".join(
+                    [
+                        fstring_format(
+                            _GROUP_LI_TEMPLATE,
+                            {
+                                "caption": name,
+                                "url": url,
+                                "description": group.description,
+                            },
+                        )
+                        for name, group in subgroups.items()
+                    ]
+                )
+            },
+        )
+    )
+    subtasks = get_subtasks(group, web_only=True)
+    task_info = (
+        ""
+        if len(subtasks) == 0
+        else fstring_format(
+            _TASK_INFO_TEMPLATE,
+            {
+                "task_li": "\n".join(
+                    [
+                        fstring_format(
+                            _TASK_LI_TEMPLATE,
+                            {
+                                "caption": name,
+                                "url": url,
+                                "description": task.description,
+                            },
+                        )
+                        for name, task in subtasks.items()
+                    ]
+                )
+            },
+        )
+    )
+    return HTMLResponse(
+        fstring_format(
+            _VIEW_TEMPLATE,
+            {
+                "group_info": group_info,
+                "task_info": task_info,
+                "name": group.name,
+                "description": group.description,
+                "root_name": root_group.name,
+                "root_description": root_group.description,
+                "url": url,
+                "parent_url": parent_url,
+            },
+        )
+    )

zrb/runner/web_controller/group_info_ui/partial/group_info.html

@@ -0,0 +1,2 @@
+<h5>Groups</h5>
+<ul>{group_li}</ul>

zrb/runner/web_controller/group_info_ui/partial/group_li.html

@@ -0,0 +1 @@
+<li><a href="{url}{caption}">{caption}</a> {description}</li>

zrb/runner/web_controller/group_info_ui/partial/task_info.html

@@ -0,0 +1,2 @@
+<h5>Tasks</h5>
+<ul>{task_li}</ul>

zrb/runner/web_controller/group_info_ui/partial/task_li.html

@@ -0,0 +1 @@
+<li><a href="{url}{caption}">{caption}</a> {description}</li>

zrb/runner/web_controller/group_info_ui/view.html

@@ -0,0 +1,31 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <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="/static/pico.min.css">
+    <link rel="icon" href="/static/favicon-32x32.png" sizes="32x32" type="image/png">
+    <title>Zrb</title>
+  </head>
+  <body>
+    <header class="container">
+      <hgroup>
+        <h1>{root_name}</h1>
+        <p>{root_description}</p>
+        <nav>
+          <ul>
+            <li><a href="/">🏠 Home</a></li>
+            <li><a href="{parent_url}">🔙 Parent</a></li>
+          </ul>
+        </nav>
+      </hgroup>
+    </header>
+    <main class="container">
+        <h3>{name}</h3>
+        <p>{description}</p>
+        {group_info}
+        {task_info}
+    </main>
+  </body>
+</html>

zrb/runner/web_controller/home_page/controller.py

@@ -0,0 +1,76 @@
+import os
+
+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__)
+
+with open(os.path.join(_DIR, "view.html"), "r") as f:
+    _VIEW_TEMPLATE = f.read()
+
+with open(os.path.join(_DIR, "partial", "group_info.html")) as f:
+    _GROUP_INFO_TEMPLATE = f.read()
+
+with open(os.path.join(_DIR, "partial", "group_li.html")) as f:
+    _GROUP_LI_TEMPLATE = f.read()
+
+with open(os.path.join(_DIR, "partial", "task_info.html")) as f:
+    _TASK_INFO_TEMPLATE = f.read()
+
+with open(os.path.join(_DIR, "partial", "task_li.html")) as f:
+    _TASK_LI_TEMPLATE = f.read()
+
+
+def handle_home_page(root_group: AnyGroup):
+    from fastapi.responses import HTMLResponse
+
+    subgroups = get_non_empty_subgroups(root_group, web_only=True)
+    group_info = (
+        ""
+        if len(subgroups) == 0
+        else fstring_format(
+            _GROUP_INFO_TEMPLATE,
+            {
+                "group_li": "\n".join(
+                    [
+                        fstring_format(
+                            _GROUP_LI_TEMPLATE,
+                            {"caption": name, "description": group.description},
+                        )
+                        for name, group in subgroups.items()
+                    ]
+                )
+            },
+        )
+    )
+    subtasks = get_subtasks(root_group, web_only=True)
+    task_info = (
+        ""
+        if len(subtasks) == 0
+        else fstring_format(
+            _TASK_INFO_TEMPLATE,
+            {
+                "task_li": "\n".join(
+                    [
+                        fstring_format(
+                            _TASK_LI_TEMPLATE,
+                            {"caption": name, "description": task.description},
+                        )
+                        for name, task in subtasks.items()
+                    ]
+                )
+            },
+        )
+    )
+    return HTMLResponse(
+        fstring_format(
+            _VIEW_TEMPLATE,
+            {
+                "group_info": group_info,
+                "task_info": task_info,
+                "name": root_group.name,
+                "description": root_group.description,
+            },
+        )
+    )

zrb/runner/web_controller/home_page/partial/group_info.html

@@ -0,0 +1,2 @@
+<h5>Groups</h5>
+<ul>{group_li}</ul>

zrb/runner/web_controller/home_page/partial/group_li.html

@@ -0,0 +1 @@
+<li><a href="/ui/{caption}">{caption}</a> {description}</li>

zrb/runner/web_controller/home_page/partial/task_info.html

@@ -0,0 +1,2 @@
+<h5>Tasks</h5>
+<ul>{task_li}</ul>

zrb/runner/web_controller/home_page/partial/task_li.html

@@ -0,0 +1 @@
+<li><a href="/ui/{caption}">{caption}</a> {description}</li>

zrb/runner/web_controller/home_page/view.html

@@ -0,0 +1,23 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <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="/static/pico.min.css">
+    <link rel="icon" href="/static/favicon-32x32.png" sizes="32x32" type="image/png">
+    <title>Zrb</title>
+  </head>
+  <body>
+    <header class="container">
+      <hgroup>
+        <h1>{name}</h1>
+        <p>{description}</p>
+      </hgroup>
+    </header>
+    <main class="container">
+        {group_info}
+        {task_info}
+    </main>
+  </body>
+</html>