zrb 1.13.1__py3-none-any.whl → 1.21.17__py3-none-any.whl

zrb/__init__.py

@@ -61,6 +61,7 @@ _LAZY_LOAD = {
 }
 
 if TYPE_CHECKING:
+    from zrb import builtin
     from zrb.attr.type import (
         AnyAttr,
         BoolAttr,
@@ -126,9 +127,4 @@ def __getattr__(name: str) -> Any:
     raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
 
 
-# Eager load CFG
-CFG = __getattr__("CFG")
-if CFG.LOAD_BUILTIN:
-    from zrb import builtin
-
-    assert builtin
+from zrb import builtin

zrb/attr/type.py

@@ -1,12 +1,12 @@
 from typing import Any, Callable
 
-from zrb.context.any_shared_context import AnySharedContext
+from zrb.context.any_context import AnyContext
 
 fstring = str
-AnyAttr = Any | fstring | Callable[[AnySharedContext], Any]
-StrAttr = str | fstring | Callable[[AnySharedContext], str]
-BoolAttr = bool | fstring | Callable[[AnySharedContext], bool]
-IntAttr = int | fstring | Callable[[AnySharedContext], int]
-FloatAttr = float | fstring | Callable[[AnySharedContext], float]
-StrDictAttr = dict[str, StrAttr] | Callable[[AnySharedContext], dict[str, Any]]
-StrListAttr = list[StrAttr] | Callable[[AnySharedContext], list[str]]
+AnyAttr = Any | fstring | Callable[[AnyContext], Any]
+StrAttr = str | fstring | Callable[[AnyContext], str | None]
+BoolAttr = bool | fstring | Callable[[AnyContext], bool | None]
+IntAttr = int | fstring | Callable[[AnyContext], int | None]
+FloatAttr = float | fstring | Callable[[AnyContext], float | None]
+StrDictAttr = dict[str, StrAttr] | Callable[[AnyContext], dict[str, Any]]
+StrListAttr = list[StrAttr] | Callable[[AnyContext], list[str]]

zrb/builtin/__init__.py

@@ -9,12 +9,14 @@ from zrb.builtin.git import (
 from zrb.builtin.git_subtree import git_add_subtree, git_pull_subtree, git_push_subtree
 from zrb.builtin.http import generate_curl, http_request
 from zrb.builtin.jwt import decode_jwt, encode_jwt, validate_jwt
+from zrb.builtin.llm.chat_trigger import llm_chat_trigger
 from zrb.builtin.llm.llm_ask import llm_ask
 from zrb.builtin.md5 import hash_md5, sum_md5, validate_md5
 from zrb.builtin.project.add.fastapp.fastapp_task import add_fastapp_to_project
 from zrb.builtin.project.create.project_task import create_project
 from zrb.builtin.python import format_python_code
 from zrb.builtin.random import shuffle_values, throw_dice
+from zrb.builtin.searxng.start import start_searxng
 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

zrb/builtin/group.py

@@ -1,39 +1,51 @@
+from zrb.config.config import CFG
 from zrb.group.group import Group
 from zrb.runner.cli import cli
 
-base64_group = cli.add_group(Group(name="base64", description="📄 Base64 operations"))
-uuid_group = cli.add_group(Group(name="uuid", description="🆔 UUID operations"))
+
+def _maybe_add_group(group: Group):
+    if CFG.LOAD_BUILTIN:
+        cli.add_group(group)
+    return group
+
+
+base64_group = _maybe_add_group(
+    Group(name="base64", description="📄 Base64 operations")
+)
+uuid_group = _maybe_add_group(Group(name="uuid", description="🆔 UUID operations"))
 uuid_v1_group = uuid_group.add_group(Group(name="v1", description="UUID V1 operations"))
 uuid_v3_group = uuid_group.add_group(Group(name="v3", description="UUID V3 operations"))
 uuid_v4_group = uuid_group.add_group(Group(name="v4", description="UUID V4 operations"))
 uuid_v5_group = uuid_group.add_group(Group(name="v5", description="UUID V5 operations"))
-ulid_group = cli.add_group(Group(name="ulid", description="🔢 ULID operations"))
-jwt_group = cli.add_group(Group(name="jwt", description="🔒 JWT encode/decode"))
-http_group = cli.add_group(Group(name="http", description="🌐 HTTP request operations"))
+ulid_group = _maybe_add_group(Group(name="ulid", description="🔢 ULID operations"))
+jwt_group = _maybe_add_group(Group(name="jwt", description="🔒 JWT encode/decode"))
+http_group = _maybe_add_group(
+    Group(name="http", description="🌐 HTTP request operations")
+)
 
-random_group = cli.add_group(Group(name="random", description="🔀 Random operation"))
-git_group = cli.add_group(Group(name="git", description="🌱 Git related commands"))
+random_group = _maybe_add_group(Group(name="random", description="🔀 Random operation"))
+git_group = _maybe_add_group(Group(name="git", description="🌱 Git related commands"))
 git_branch_group = git_group.add_group(
     Group(name="branch", description="🌿 Git branch related commands")
 )
 git_subtree_group = git_group.add_group(
     Group(name="subtree", description="🌳 Git subtree related commands")
 )
-llm_group = cli.add_group(Group(name="llm", description="🤖 LLM operations"))
-md5_group = cli.add_group(Group(name="md5", description="🔢 Md5 operations"))
-python_group = cli.add_group(
+llm_group = _maybe_add_group(Group(name="llm", description="🤖 LLM operations"))
+md5_group = _maybe_add_group(Group(name="md5", description="🔢 Md5 operations"))
+python_group = _maybe_add_group(
     Group(name="python", description="🐍 Python related commands")
 )
-todo_group = cli.add_group(Group(name="todo", description="✅ Todo management"))
+todo_group = _maybe_add_group(Group(name="todo", description="✅ Todo management"))
 
-shell_group = cli.add_group(
+shell_group = _maybe_add_group(
     Group(name="shell", description="💬 Shell related commands")
 )
-shell_autocomplete_group: Group = shell_group.add_group(
+shell_autocomplete_group = shell_group.add_group(
     Group(name="autocomplete", description="⌨️ Shell autocomplete related commands")
 )
 
-project_group = cli.add_group(
+project_group = _maybe_add_group(
     Group(name="project", description="📁 Project related commands")
 )
 add_to_project_group = project_group.add_group(
@@ -43,7 +55,11 @@ add_fastapp_to_project_group = add_to_project_group.add_group(
     Group(name="fastapp", description="🚀 Add Fastapp resources")
 )
 
-setup_group = cli.add_group(Group(name="setup", description="🔧 Setup"))
+setup_group = _maybe_add_group(Group(name="setup", description="🔧 Setup"))
 setup_latex_group = setup_group.add_group(
     Group(name="latex", description="✍️ Setup LaTeX")
 )
+
+searxng_group = _maybe_add_group(
+    Group(name="searxng", description="🔎 Searxng related command")
+)

zrb/builtin/http.py

@@ -2,6 +2,7 @@ from typing import Any
 
 from zrb.builtin.group import http_group
 from zrb.context.any_context import AnyContext
+from zrb.input.bool_input import BoolInput
 from zrb.input.option_input import OptionInput
 from zrb.input.str_input import StrInput
 from zrb.task.make_task import make_task
@@ -32,10 +33,9 @@ from zrb.task.make_task import make_task
             prompt="Enter body as JSON",
             default="{}",
         ),
-        OptionInput(
+        BoolInput(
             name="verify_ssl",
-            default="true",
-            options=["true", "false"],
+            default=True,
             description="Verify SSL certificate",
         ),
     ],
@@ -55,7 +55,7 @@ def http_request(ctx: AnyContext) -> Any:
             body = json.loads(ctx.input.body)
 
         # Make request
-        verify = ctx.input.verify_ssl.lower() == "true"
+        verify = ctx.input.verify_ssl
         response = requests.request(
             method=ctx.input.method,
             url=ctx.input.url,
@@ -107,10 +107,9 @@ def http_request(ctx: AnyContext) -> Any:
             prompt="Enter body as JSON",
             default="{}",
         ),
-        OptionInput(
+        BoolInput(
             name="verify_ssl",
-            default="true",
-            options=["true", "false"],
+            default=True,
             description="Verify SSL certificate",
         ),
     ],
@@ -137,7 +136,7 @@ def generate_curl(ctx: AnyContext) -> str:
             parts.extend(["--data-raw", shlex.quote(ctx.input.body)])
 
         # Add SSL verification
-        if ctx.input.verify_ssl.lower() == "false":
+        if not ctx.input.verify_ssl:
             parts.append("--insecure")
 
         # Add URL

zrb/builtin/llm/attachment.py

@@ -0,0 +1,40 @@
+def get_media_type(filename: str) -> str | None:
+    """Guess media type string based on file extension."""
+    ext = filename.lower().rsplit(".", 1)[-1] if "." in filename else ""
+    mapping: dict[str, str] = {
+        # Audio
+        "wav": "audio/wav",
+        "mp3": "audio/mpeg",
+        "ogg": "audio/ogg",
+        "flac": "audio/flac",
+        "aiff": "audio/aiff",
+        "aac": "audio/aac",
+        # Image
+        "jpg": "image/jpeg",
+        "jpeg": "image/jpeg",
+        "png": "image/png",
+        "gif": "image/gif",
+        "webp": "image/webp",
+        # Document
+        "pdf": "application/pdf",
+        "txt": "text/plain",
+        "csv": "text/csv",
+        "docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+        "xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        "html": "text/html",
+        "htm": "text/html",
+        "md": "text/markdown",
+        "doc": "application/msword",
+        "xls": "application/vnd.ms-excel",
+        # Video
+        "mkv": "video/x-matroska",
+        "mov": "video/quicktime",
+        "mp4": "video/mp4",
+        "webm": "video/webm",
+        "flv": "video/x-flv",
+        "mpeg": "video/mpeg",
+        "mpg": "video/mpeg",
+        "wmv": "video/x-ms-wmv",
+        "3gp": "video/3gpp",
+    }
+    return mapping.get(ext)

zrb/builtin/llm/chat_session.py

@@ -1,16 +1,37 @@
-"""
-This module provides functions for managing interactive chat sessions with an LLM.
-
-It handles reading user input, triggering the LLM task, and managing the
-conversation flow via XCom.
-"""
-
 import asyncio
 import sys
-
+from typing import TYPE_CHECKING, Any
+
+from zrb.builtin.llm.chat_session_cmd import (
+    ATTACHMENT_CMD,
+    HELP_CMD,
+    MULTILINE_END_CMD,
+    MULTILINE_START_CMD,
+    QUIT_CMD,
+    RUN_CLI_CMD,
+    SAVE_CMD,
+    WORKFLOW_CMD,
+    YOLO_CMD,
+    get_new_attachments,
+    get_new_workflows,
+    get_new_yolo_mode,
+    is_command_match,
+    print_commands,
+    print_current_attachments,
+    print_current_workflows,
+    print_current_yolo_mode,
+    run_cli_command,
+    save_final_result,
+)
+from zrb.builtin.llm.chat_trigger import llm_chat_trigger
 from zrb.config.llm_config import llm_config
 from zrb.context.any_context import AnyContext
-from zrb.util.cli.style import stylize_bold_yellow, stylize_faint
+from zrb.util.cli.markdown import render_markdown
+
+if TYPE_CHECKING:
+    from asyncio import StreamReader
+
+    from prompt_toolkit import PromptSession
 
 
 async def read_user_prompt(ctx: AnyContext) -> str:
@@ -18,114 +39,97 @@ async def read_user_prompt(ctx: AnyContext) -> str:
     Reads user input from the CLI for an interactive chat session.
     Orchestrates the session by calling helper functions.
     """
-    _show_info(ctx)
-    final_result = await _handle_initial_message(ctx)
-    if ctx.is_web_mode:
-        return final_result
-    is_tty = ctx.is_tty
-    reader = await _setup_input_reader(is_tty)
+    print_commands(ctx)
+    is_tty: bool = ctx.is_tty
+    reader: PromptSession[Any] | StreamReader = await _setup_input_reader(is_tty)
     multiline_mode = False
-    current_modes = ctx.input.modes
-    user_inputs = []
-    while True:
+    is_first_time = True
+    current_workflows: str = ctx.input.workflows
+    current_yolo_mode: bool | str = ctx.input.yolo
+    current_attachments: str = ctx.input.attach
+    user_inputs: list[str] = []
+    final_result: str = ""
+    should_end = False
+    while not should_end:
         await asyncio.sleep(0.01)
-        # Get user input based on mode
-        if not multiline_mode:
-            ctx.print("💬 >>", plain=True)
-        user_input = await _read_next_line(is_tty, reader, ctx)
-        if not multiline_mode:
-            ctx.print("", plain=True)
-        # Handle user input
-        if user_input.strip().lower() in ("/bye", "/quit", "/q", "/exit"):
-            user_prompt = "\n".join(user_inputs)
-            user_inputs = []
-            result = await _trigger_ask_and_wait_for_result(
-                ctx, user_prompt, current_modes
-            )
-            if result is not None:
-                final_result = result
-            break
-        elif user_input.strip().lower() in ("/multi",):
-            multiline_mode = True
-        elif user_input.strip().lower() in ("/end",):
-            ctx.print("", plain=True)
-            multiline_mode = False
-            user_prompt = "\n".join(user_inputs)
-            user_inputs = []
-            result = await _trigger_ask_and_wait_for_result(
-                ctx, user_prompt, current_modes
-            )
-            if result is not None:
-                final_result = result
-        elif user_input.strip().lower().startswith("/mode"):
-            mode_parts = user_input.split(" ", maxsplit=2)
-            if len(mode_parts) > 1:
-                current_modes = mode_parts[1]
-            ctx.print(f"Current mode: {current_modes}", plain=True)
-            ctx.print("", plain=True)
-            continue
-        elif user_input.strip().lower() in ("/help", "/info"):
-            _show_info(ctx)
-            continue
+        previous_session_name: str | None = (
+            ctx.input.previous_session if is_first_time else ""
+        )
+        start_new: bool = ctx.input.start_new if is_first_time else False
+        if is_first_time and ctx.input.message.strip() != "":
+            user_input = ctx.input.message
         else:
-            user_inputs.append(user_input)
-            if multiline_mode:
+            # Get user input based on mode
+            if not multiline_mode:
+                ctx.print("💬 >>", plain=True)
+            user_input = await llm_chat_trigger.wait(reader, ctx)
+            if not multiline_mode:
+                ctx.print("", plain=True)
+        # At this point, is_first_time has to be False
+        if is_first_time:
+            is_first_time = False
+        # Handle user input (including slash commands)
+        if multiline_mode:
+            if is_command_match(user_input, MULTILINE_END_CMD):
+                ctx.print("", plain=True)
+                multiline_mode = False
+            else:
+                user_inputs.append(user_input)
+                continue
+        else:
+            if is_command_match(user_input, QUIT_CMD):
+                should_end = True
+            elif is_command_match(user_input, MULTILINE_START_CMD):
+                multiline_mode = True
+                ctx.print("", plain=True)
+                continue
+            elif is_command_match(user_input, WORKFLOW_CMD):
+                current_workflows = get_new_workflows(current_workflows, user_input)
+                print_current_workflows(ctx, current_workflows)
+                continue
+            elif is_command_match(user_input, SAVE_CMD):
+                save_final_result(ctx, user_input, final_result)
+                continue
+            elif is_command_match(user_input, ATTACHMENT_CMD):
+                current_attachments = get_new_attachments(
+                    current_attachments, user_input
+                )
+                print_current_attachments(ctx, current_attachments)
                 continue
-            user_prompt = "\n".join(user_inputs)
-            user_inputs = []
-            result = await _trigger_ask_and_wait_for_result(
-                ctx, user_prompt, current_modes
-            )
-            if result is not None:
-                final_result = result
+            elif is_command_match(user_input, YOLO_CMD):
+                current_yolo_mode = get_new_yolo_mode(current_yolo_mode, user_input)
+                print_current_yolo_mode(ctx, current_yolo_mode)
+                continue
+            elif is_command_match(user_input, RUN_CLI_CMD):
+                run_cli_command(ctx, user_input)
+                continue
+            elif is_command_match(user_input, HELP_CMD):
+                print_commands(ctx)
+                continue
+            else:
+                user_inputs.append(user_input)
+        # Trigger LLM
+        user_prompt = "\n".join(user_inputs)
+        user_inputs = []
+        result = await _trigger_ask_and_wait_for_result(
+            ctx=ctx,
+            user_prompt=user_prompt,
+            attach=current_attachments,
+            workflows=current_workflows,
+            yolo_mode=current_yolo_mode,
+            previous_session_name=previous_session_name,
+            start_new=start_new,
+        )
+        current_attachments = ""
+        final_result = final_result if result is None else result
+        if ctx.is_web_mode or not is_tty:
+            return final_result
     return final_result
 
 
-def _show_info(ctx: AnyContext):
-    """
-    Displays the available chat session commands to the user.
-    Args:
-        ctx: The context object for the task.
-    """
-    ctx.print(
-        "\n".join(
-            [
-                _format_info_line("/bye", "Quit from chat session"),
-                _format_info_line("/multi", "Start multiline input"),
-                _format_info_line("/end", "End multiline input"),
-                _format_info_line("/modes", "Show current modes"),
-                _format_info_line("/modes <mode1,mode2,..>", "Set current modes"),
-                _format_info_line("/help", "Show this message"),
-            ]
-        ),
-        plain=True,
-    )
-
-
-def _format_info_line(command: str, description: str) -> str:
-    styled_command = stylize_bold_yellow(command.ljust(25))
-    styled_description = stylize_faint(description)
-    return f"  {styled_command} {styled_description}"
-
-
-async def _handle_initial_message(ctx: AnyContext) -> str:
-    """Processes the initial message from the command line."""
-    if not ctx.input.message or ctx.input.message.strip() == "":
-        return ""
-    ctx.print("💬 >>", plain=True)
-    ctx.print(ctx.input.message, plain=True)
-    ctx.print("", plain=True)
-    result = await _trigger_ask_and_wait_for_result(
-        ctx,
-        user_prompt=ctx.input.message,
-        modes=ctx.input.modes,
-        previous_session_name=ctx.input.previous_session,
-        start_new=ctx.input.start_new,
-    )
-    return result if result is not None else ""
-
-
-async def _setup_input_reader(is_interactive: bool):
+async def _setup_input_reader(
+    is_interactive: bool,
+) -> "PromptSession[Any] | StreamReader":
     """Sets up and returns the appropriate asynchronous input reader."""
     if is_interactive:
         from prompt_toolkit import PromptSession
@@ -139,24 +143,12 @@ async def _setup_input_reader(is_interactive: bool):
     return reader
 
 
-async def _read_next_line(is_interactive: bool, reader, ctx: AnyContext) -> str:
-    """Reads one line of input using the provided reader."""
-    if is_interactive:
-        return await reader.prompt_async()
-
-    line_bytes = await reader.readline()
-    if not line_bytes:
-        return "/bye"  # Signal to exit
-
-    user_input = line_bytes.decode().strip()
-    ctx.print(user_input, plain=True)
-    return user_input
-
-
 async def _trigger_ask_and_wait_for_result(
     ctx: AnyContext,
     user_prompt: str,
-    modes: str,
+    attach: str,
+    workflows: str,
+    yolo_mode: bool | str,
     previous_session_name: str | None = None,
     start_new: bool = False,
 ) -> str | None:
@@ -174,29 +166,17 @@ async def _trigger_ask_and_wait_for_result(
     """
     if user_prompt.strip() == "":
         return None
-    await _trigger_ask(ctx, user_prompt, modes, previous_session_name, start_new)
+    await _trigger_ask(
+        ctx, user_prompt, attach, workflows, yolo_mode, previous_session_name, start_new
+    )
     result = await _wait_ask_result(ctx)
-    md_result = _render_markdown(result) if result is not None else ""
+    md_result = render_markdown(result) if result is not None else ""
     ctx.print("\n🤖 >>", plain=True)
     ctx.print(md_result, plain=True)
     ctx.print("", plain=True)
     return result
 
 
-def _render_markdown(markdown_text: str) -> str:
-    """
-    Renders Markdown to a string, ensuring link URLs are visible.
-    """
-    from rich.console import Console
-    from rich.markdown import Markdown
-
-    console = Console()
-    markdown = Markdown(markdown_text, hyperlinks=False)
-    with console.capture() as capture:
-        console.print(markdown)
-    return capture.get()
-
-
 def get_llm_ask_input_mapping(callback_ctx: AnyContext):
     """
     Generates the input mapping for the LLM ask task from the callback context.
@@ -219,14 +199,18 @@ def get_llm_ask_input_mapping(callback_ctx: AnyContext):
         "start-new": data.get("start_new"),
         "previous-session": data.get("previous_session_name"),
         "message": data.get("message"),
-        "modes": data.get("modes"),
+        "attach": data.get("attach"),
+        "workflows": data.get("workflows"),
+        "yolo": data.get("yolo"),
     }
 
 
 async def _trigger_ask(
     ctx: AnyContext,
     user_prompt: str,
-    modes: str,
+    attach: str,
+    workflows: str,
+    yolo_mode: bool | str,
     previous_session_name: str | None = None,
     start_new: bool = False,
 ):
@@ -246,7 +230,9 @@ async def _trigger_ask(
             "previous_session_name": previous_session_name,
             "start_new": start_new,
             "message": user_prompt,
-            "modes": modes,
+            "attach": attach,
+            "workflows": workflows,
+            "yolo": yolo_mode,
         }
     )