zrb 1.13.1__py3-none-any.whl → 1.21.33__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,15 @@
 from typing import Any, Callable
 
+from zrb.context.any_context import AnyContext
 from zrb.context.any_shared_context import AnySharedContext
 
 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 | AnySharedContext], Any]
+StrAttr = str | fstring | Callable[[AnyContext | AnySharedContext], str | None]
+BoolAttr = bool | fstring | Callable[[AnyContext | AnySharedContext], bool | None]
+IntAttr = int | fstring | Callable[[AnyContext | AnySharedContext], int | None]
+FloatAttr = float | fstring | Callable[[AnyContext | AnySharedContext], float | None]
+StrDictAttr = (
+    dict[str, StrAttr] | Callable[[AnyContext | AnySharedContext], dict[str, Any]]
+)
+StrListAttr = list[StrAttr] | Callable[[AnyContext | AnySharedContext], 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/git.py

@@ -82,6 +82,12 @@ async def get_git_diff(ctx: AnyContext):
 
 @make_task(
     name="prune-local-git-branches",
+    input=StrInput(
+        name="preserved-branch",
+        description="Branches to be preserved",
+        prompt="Branches to be preserved, comma separated",
+        default="master,main,dev,develop",
+    ),
     description="🧹 Prune local branches",
     group=git_branch_group,
     alias="prune",
@@ -93,8 +99,13 @@ async def prune_local_branches(ctx: AnyContext):
     branches = await get_branches(repo_dir, print_method=ctx.print)
     ctx.print(stylize_faint("Get current branch"))
     current_branch = await get_current_branch(repo_dir, print_method=ctx.print)
+    preserved_branches = [
+        branch.strip()
+        for branch in ctx.input.preserved_branch.split(",")
+        if branch.strip() != ""
+    ]
     for branch in branches:
-        if branch == current_branch or branch == "main" or branch == "master":
+        if branch == current_branch or branch in preserved_branches:
             continue
         ctx.print(stylize_faint(f"Removing local branch: {branch}"))
         try:

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_completion.py

@@ -0,0 +1,287 @@
+import os
+from typing import TYPE_CHECKING
+
+from zrb.builtin.llm.chat_session_cmd import (
+    ADD_SUB_CMD,
+    ATTACHMENT_ADD_SUB_CMD_DESC,
+    ATTACHMENT_CLEAR_SUB_CMD_DESC,
+    ATTACHMENT_CMD,
+    ATTACHMENT_CMD_DESC,
+    ATTACHMENT_SET_SUB_CMD_DESC,
+    CLEAR_SUB_CMD,
+    HELP_CMD,
+    HELP_CMD_DESC,
+    MULTILINE_END_CMD,
+    MULTILINE_END_CMD_DESC,
+    MULTILINE_START_CMD,
+    MULTILINE_START_CMD_DESC,
+    QUIT_CMD,
+    QUIT_CMD_DESC,
+    RUN_CLI_CMD,
+    RUN_CLI_CMD_DESC,
+    SAVE_CMD,
+    SAVE_CMD_DESC,
+    SET_SUB_CMD,
+    WORKFLOW_ADD_SUB_CMD_DESC,
+    WORKFLOW_CLEAR_SUB_CMD_DESC,
+    WORKFLOW_CMD,
+    WORKFLOW_CMD_DESC,
+    WORKFLOW_SET_SUB_CMD_DESC,
+    YOLO_CMD,
+    YOLO_CMD_DESC,
+    YOLO_SET_CMD_DESC,
+    YOLO_SET_FALSE_CMD_DESC,
+    YOLO_SET_TRUE_CMD_DESC,
+)
+
+if TYPE_CHECKING:
+    from prompt_toolkit.completion import Completer
+
+
+def get_chat_completer() -> "Completer":
+
+    from prompt_toolkit.completion import CompleteEvent, Completer, Completion
+    from prompt_toolkit.document import Document
+
+    class ChatCompleter(Completer):
+
+        def get_completions(self, document: Document, complete_event: CompleteEvent):
+            # Slash command
+            for completion in self._complete_slash_command(document):
+                yield completion
+            for completion in self._complete_slash_file_command(document):
+                yield completion
+            # Appendix
+            for completion in self._complete_appendix(document):
+                yield completion
+
+        def _complete_slash_file_command(self, document: Document):
+            text = document.text_before_cursor
+            prefixes = []
+            for cmd in ATTACHMENT_CMD:
+                for subcmd in ADD_SUB_CMD:
+                    prefixes.append(f"{cmd} {subcmd} ")
+            for prefix in prefixes:
+                if text.startswith(prefix):
+                    pattern = text[len(prefix) :]
+                    potential_options = self._fuzzy_path_search(pattern, dirs=False)
+                    for prefixed_option in [
+                        f"{prefix}{option}" for option in potential_options
+                    ]:
+                        yield Completion(
+                            prefixed_option,
+                            start_position=-len(text),
+                        )
+
+        def _complete_slash_command(self, document: Document):
+            text = document.text_before_cursor
+            if not text.startswith("/"):
+                return
+            for command, description in self._get_cmd_options().items():
+                if command.lower().startswith(text.lower()):
+                    yield Completion(
+                        command,
+                        start_position=-len(text),
+                        display_meta=description,
+                    )
+
+        def _complete_appendix(self, document: Document):
+            token = document.get_word_before_cursor(WORD=True)
+            prefix = "@"
+            if not token.startswith(prefix):
+                return
+            pattern = token[len(prefix) :]
+            potential_options = self._fuzzy_path_search(pattern, dirs=False)
+            for prefixed_option in [
+                f"{prefix}{option}" for option in potential_options
+            ]:
+                yield Completion(
+                    prefixed_option,
+                    start_position=-len(token),
+                )
+
+        def _get_cmd_options(self):
+            cmd_options = {}
+            # Add all commands with their descriptions
+            for cmd in MULTILINE_START_CMD:
+                cmd_options[cmd] = MULTILINE_START_CMD_DESC
+            for cmd in MULTILINE_END_CMD:
+                cmd_options[cmd] = MULTILINE_END_CMD_DESC
+            for cmd in QUIT_CMD:
+                cmd_options[cmd] = QUIT_CMD_DESC
+            for cmd in WORKFLOW_CMD:
+                cmd_options[cmd] = WORKFLOW_CMD_DESC
+                for subcmd in ADD_SUB_CMD:
+                    cmd_options[f"{cmd} {subcmd}"] = WORKFLOW_ADD_SUB_CMD_DESC
+                for subcmd in CLEAR_SUB_CMD:
+                    cmd_options[f"{cmd} {subcmd}"] = WORKFLOW_CLEAR_SUB_CMD_DESC
+                for subcmd in SET_SUB_CMD:
+                    cmd_options[f"{cmd} {subcmd}"] = WORKFLOW_SET_SUB_CMD_DESC
+            for cmd in SAVE_CMD:
+                cmd_options[cmd] = SAVE_CMD_DESC
+            for cmd in ATTACHMENT_CMD:
+                cmd_options[cmd] = ATTACHMENT_CMD_DESC
+                for subcmd in ADD_SUB_CMD:
+                    cmd_options[f"{cmd} {subcmd}"] = ATTACHMENT_ADD_SUB_CMD_DESC
+                for subcmd in CLEAR_SUB_CMD:
+                    cmd_options[f"{cmd} {subcmd}"] = ATTACHMENT_CLEAR_SUB_CMD_DESC
+                for subcmd in SET_SUB_CMD:
+                    cmd_options[f"{cmd} {subcmd}"] = ATTACHMENT_SET_SUB_CMD_DESC
+            for cmd in YOLO_CMD:
+                cmd_options[cmd] = YOLO_CMD_DESC
+                for subcmd in SET_SUB_CMD:
+                    cmd_options[f"{cmd} {subcmd} true"] = YOLO_SET_TRUE_CMD_DESC
+                    cmd_options[f"{cmd} {subcmd} false"] = YOLO_SET_FALSE_CMD_DESC
+                    cmd_options[f"{cmd} {subcmd}"] = YOLO_SET_CMD_DESC
+            for cmd in HELP_CMD:
+                cmd_options[cmd] = HELP_CMD_DESC
+            for cmd in RUN_CLI_CMD:
+                cmd_options[cmd] = RUN_CLI_CMD_DESC
+            return dict(sorted(cmd_options.items()))
+
+        def _fuzzy_path_search(
+            self,
+            pattern: str,
+            root: str | None = None,
+            max_results: int = 20,
+            include_hidden: bool = False,
+            case_sensitive: bool = False,
+            dirs: bool = True,
+            files: bool = True,
+        ) -> list[str]:
+            """
+            Return a list of filesystem paths under `root` that fuzzy-match `pattern`.
+            - pattern: e.g. "./some/x" or "proj util/io"
+            - include_hidden: if False skip files/dirs starting with '.'
+            - dirs/files booleans let you restrict results
+            - returns list of relative paths (from root), sorted best-first
+            """
+            search_pattern = pattern
+            if root is None:
+                # Determine root and adjust pattern if necessary
+                expanded_pattern = os.path.expanduser(pattern)
+                if os.path.isabs(expanded_pattern) or pattern.startswith("~"):
+                    # For absolute paths, find the deepest existing directory
+                    if os.path.isdir(expanded_pattern):
+                        root = expanded_pattern
+                        search_pattern = ""
+                    else:
+                        root = os.path.dirname(expanded_pattern)
+                        while root and not os.path.isdir(root) and len(root) > 1:
+                            root = os.path.dirname(root)
+                        if not os.path.isdir(root):
+                            root = "."  # Fallback
+                            search_pattern = pattern
+                        else:
+                            try:
+                                search_pattern = os.path.relpath(expanded_pattern, root)
+                                if search_pattern == ".":
+                                    search_pattern = ""
+                            except ValueError:
+                                search_pattern = os.path.basename(pattern)
+                else:
+                    root = "."
+                    search_pattern = pattern
+            # Normalize pattern -> tokens split on path separators or whitespace
+            search_pattern = search_pattern.strip()
+            if search_pattern:
+                raw_tokens = [t for t in search_pattern.split(os.path.sep) if t]
+            else:
+                raw_tokens = []
+            # prepare tokens (case)
+            if not case_sensitive:
+                tokens = [t.lower() for t in raw_tokens]
+            else:
+                tokens = raw_tokens
+            # specific ignore list
+            try:
+                is_recursive = os.path.abspath(os.path.expanduser(root)).startswith(
+                    os.path.abspath(os.getcwd())
+                )
+            except Exception:
+                is_recursive = False
+            # walk filesystem
+            candidates: list[tuple[float, str]] = []
+            for dirpath, dirnames, filenames in os.walk(root):
+                # Filter directories
+                if not include_hidden:
+                    dirnames[:] = [d for d in dirnames if not d.startswith(".")]
+                rel_dir = os.path.relpath(dirpath, root)
+                # treat '.' as empty prefix
+                if rel_dir == ".":
+                    rel_dir = ""
+                # build list of entries to test depending on files/dirs flags
+                entries = []
+                if dirs:
+                    entries.extend([os.path.join(rel_dir, d) for d in dirnames])
+                if files:
+                    entries.extend([os.path.join(rel_dir, f) for f in filenames])
+                if not is_recursive:
+                    dirnames[:] = []
+                for ent in entries:
+                    # Normalize presentation: use ./ prefix for relative paths
+                    display_path = ent if ent else "."
+                    # Skip hidden entries unless requested (double check for rel path segments)
+                    if not include_hidden:
+                        if any(
+                            seg.startswith(".")
+                            for seg in display_path.split(os.sep)
+                            if seg
+                        ):
+                            continue
+                    cand = display_path.replace(os.sep, "/")  # unify separator
+                    cand_cmp = cand if case_sensitive else cand.lower()
+                    last_pos = 0
+                    score = 0.0
+                    matched_all = True
+                    for token in tokens:
+                        # try contiguous substring search first
+                        idx = cand_cmp.find(token, last_pos)
+                        if idx != -1:
+                            # good match: reward contiguous early matches
+                            score += idx  # smaller idx preferred
+                            last_pos = idx + len(token)
+                        else:
+                            # fallback to subsequence matching
+                            pos = self._find_subsequence_pos(cand_cmp, token, last_pos)
+                            if pos is None:
+                                matched_all = False
+                                break
+                            # subsequence match is less preferred than contiguous substring
+                            score += pos + 0.5 * len(token)
+                            last_pos = pos + len(token)
+                    if matched_all:
+                        # prefer shorter paths when score ties, so include length as tiebreaker
+                        score += 0.01 * len(cand)
+                        out = (
+                            cand
+                            if os.path.abspath(cand) == cand
+                            else os.path.join(root, cand)
+                        )
+                        candidates.append((score, out))
+            # sort by score then lexicographically and return top results
+            candidates.sort(key=lambda x: (x[0], x[1]))
+            return [p for _, p in candidates[:max_results]]
+
+        def _find_subsequence_pos(
+            self, hay: str, needle: str, start: int = 0
+        ) -> int | None:
+            """
+            Try to locate needle in hay as a subsequence starting at `start`.
+            Returns the index of the first matched character of the subsequence or None if not
+            match.
+            """
+            if not needle:
+                return start
+            i = start
+            j = 0
+            first_pos = None
+            while i < len(hay) and j < len(needle):
+                if hay[i] == needle[j]:
+                    if first_pos is None:
+                        first_pos = i
+                    j += 1
+                i += 1
+            return first_pos if j == len(needle) else None
+
+    return ChatCompleter()