zrb 0.26.2__py3-none-any.whl → 1.0.0a5__py3-none-any.whl

zrb/util/git.py

@@ -0,0 +1,156 @@
+import subprocess
+
+from pydantic import BaseModel
+
+
+class DiffResult(BaseModel):
+    created: list[str]
+    removed: list[str]
+    updated: list[str]
+
+
+def get_diff(source_commit: str, current_commit: str) -> DiffResult:
+    # git show b176b5a main
+    exit_status, output = subprocess.getstatusoutput(
+        f"git diff {source_commit} {current_commit}"
+    )
+    if exit_status != 0:
+        raise Exception(output)
+    lines = output.split("\n")
+    diff: dict[str, dict[str, bool]] = {}
+    for line in lines:
+        if not line.startswith("---") and not line.startswith("+++"):
+            continue
+        if line[4:6] != "a/" and line[4:6] != "b/":
+            continue
+        # line should contains something like `--- a/some-file.txt`
+        file = line[6:]
+        if file not in diff:
+            diff[file] = {"plus": False, "minus": False}
+        if line.startswith("---"):
+            diff[file]["minus"] = True
+        if line.startswith("+++"):
+            diff[file]["plus"] = True
+    return DiffResult(
+        created=[
+            file for file, state in diff.items() if state["plus"] and not state["minus"]
+        ],
+        removed=[
+            file for file, state in diff.items() if not state["plus"] and state["minus"]
+        ],
+        updated=[
+            file for file, state in diff.items() if state["plus"] and state["minus"]
+        ],
+    )
+
+
+def get_repo_dir() -> str:
+    try:
+        # Run the Git command to get the repository's top-level directory
+        result = subprocess.run(
+            ["git", "rev-parse", "--show-toplevel"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            check=True,
+        )
+        # Return the directory path
+        return result.stdout.strip()
+    except subprocess.CalledProcessError as e:
+        raise Exception(e.stderr or e.stdout)
+
+
+def get_current_branch() -> str:
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            check=True,
+        )
+        return result.stdout.strip()
+    except subprocess.CalledProcessError as e:
+        raise Exception(e.stderr or e.stdout)
+
+
+def get_branches() -> list[str]:
+    try:
+        result = subprocess.run(
+            ["git", "branch"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            check=True,
+        )
+        return [
+            branch.lstrip("*").strip() for branch in result.stdout.strip().split("\n")
+        ]
+    except subprocess.CalledProcessError as e:
+        raise Exception(e.stderr or e.stdout)
+
+
+def delete_branch(branch_name: str) -> str:
+    try:
+        result = subprocess.run(
+            ["git", "branch", "-D", branch_name],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            check=True,
+        )
+        return result.stdout.strip()
+    except subprocess.CalledProcessError as e:
+        raise Exception(e.stderr or e.stdout)
+
+
+def add() -> str:
+    try:
+        subprocess.run(
+            ["git", "add", ".", "-A"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            check=True,
+        )
+    except subprocess.CalledProcessError as e:
+        raise Exception(e.stderr or e.stdout)
+
+
+def commit(message: str) -> str:
+    try:
+        subprocess.run(
+            ["git", "commit", "-m", message],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            check=True,
+        )
+    except subprocess.CalledProcessError as e:
+        raise Exception(e.stderr or e.stdout)
+
+
+def pull(remote: str, branch: str) -> str:
+    try:
+        subprocess.run(
+            ["git", "pull", remote, branch],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            check=True,
+        )
+    except subprocess.CalledProcessError as e:
+        raise Exception(e.stderr or e.stdout)
+
+
+def push(remote: str, branch: str) -> str:
+    try:
+        subprocess.run(
+            ["git", "push", "-u", remote, branch],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            check=True,
+        )
+    except subprocess.CalledProcessError as e:
+        raise Exception(e.stderr or e.stdout)

zrb/util/git_subtree.py

@@ -0,0 +1,94 @@
+import os
+import subprocess
+
+from pydantic import BaseModel
+
+from zrb.util.git import get_repo_dir
+
+
+class SingleSubTreeConfig(BaseModel):
+    repo_url: str
+    branch: str
+    prefix: str
+
+
+class SubTreeConfig(BaseModel):
+    data: dict[str, SingleSubTreeConfig]
+
+
+def load_config() -> SubTreeConfig:
+    file_path = os.path.join(get_repo_dir(), "subtrees.json")
+    if not os.path.exists(file_path):
+        return SubTreeConfig(data={})
+    with open(file_path, "r") as f:
+        return SubTreeConfig.model_validate_json(f.read())
+
+
+def save_config(config: SubTreeConfig):
+    file_path = os.path.join(get_repo_dir(), "subtrees.json")
+    with open(file_path, "w") as f:
+        f.write(config.model_dump_json(indent=2))
+
+
+def add_subtree(name: str, repo_url: str, branch: str, prefix: str):
+    config = load_config()
+    if os.path.isdir(prefix):
+        raise ValueError(f"Directory exists: {prefix}")
+    if name in config.data:
+        raise ValueError(f"Subtree config already exists: {name}")
+    try:
+        subprocess.run(
+            ["git", "subtree", "add", "--prefix", prefix, repo_url, branch],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            check=True,
+        )
+    except subprocess.CalledProcessError as e:
+        raise Exception(e.stderr or e.stdout)
+    config.data[name] = SingleSubTreeConfig(
+        repo_url=repo_url, branch=branch, prefix=prefix
+    )
+    save_config(config)
+
+
+def pull_subtree(prefix: str, repo_url: str, branch: str):
+    try:
+        subprocess.run(
+            [
+                "git",
+                "subtree",
+                "pull",
+                "--prefix",
+                prefix,
+                repo_url,
+                branch,
+            ],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            check=True,
+        )
+    except subprocess.CalledProcessError as e:
+        raise Exception(e.stderr or e.stdout)
+
+
+def push_subtree(prefix: str, repo_url: str, branch: str):
+    try:
+        subprocess.run(
+            [
+                "git",
+                "subtree",
+                "push",
+                "--prefix",
+                prefix,
+                repo_url,
+                branch,
+            ],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            check=True,
+        )
+    except subprocess.CalledProcessError as e:
+        raise Exception(e.stderr or e.stdout)

zrb/util/group.py

@@ -0,0 +1,86 @@
+from zrb.group.any_group import AnyGroup
+from zrb.task.any_task import AnyTask
+
+
+class NodeNotFoundError(ValueError):
+    pass
+
+
+def extract_node_from_args(
+    root_group: AnyGroup, args: list[str], web_only: bool = False
+) -> tuple[AnyGroup | AnyTask, list[str], list[str]]:
+    node = root_group
+    node_path = []
+    residual_args = []
+    for index, name in enumerate(args):
+        task = node.get_task_by_alias(name)
+        if web_only and task is not None and task.cli_only:
+            task = None
+        group = node.get_group_by_alias(name)
+        if group is not None and len(get_all_subtasks(group, web_only)) == 0:
+            # If group doesn't contain any task, then ignore its existence
+            group = None
+        if task is None and group is None:
+            raise NodeNotFoundError(
+                f"Invalid subcommand: {root_group.name} {' '.join(args)}"
+            )
+        node_path.append(name)
+        if group is not None:
+            if task is not None and index == len(args) - 1:
+                node = task
+                residual_args = args[index + 1 :]
+                break
+            node = group
+            continue
+        if task is not None:
+            node = task
+            residual_args = args[index + 1 :]
+            break
+    return node, node_path, residual_args
+
+
+def get_node_path(group: AnyGroup, node: AnyGroup | AnyTask) -> list[str] | None:
+    if group is None:
+        return []
+    if isinstance(node, AnyTask):
+        for alias, subtask in group.subtasks.items():
+            if subtask == node:
+                return [alias]
+    if isinstance(node, AnyGroup):
+        for alias, subgroup in group.subgroups.items():
+            if subgroup == node:
+                return [alias]
+    for alias, subgroup in group.subgroups.items():
+        result = get_node_path(subgroup, node)
+        if result is not None:
+            return [alias] + result
+    return None
+
+
+def get_non_empty_subgroups(
+    group: AnyGroup, web_only: bool = False
+) -> dict[str, AnyGroup]:
+    return {
+        alias: subgroup
+        for alias, subgroup in group.subgroups.items()
+        if len(get_all_subtasks(subgroup, web_only)) > 0
+    }
+
+
+def get_subtasks(group: AnyGroup, web_only: bool = False) -> dict[str, AnyTask]:
+    return {
+        alias: subtask
+        for alias, subtask in group.subtasks.items()
+        if not web_only or (web_only and not subtask.cli_only)
+    }
+
+
+def get_all_subtasks(group: AnyGroup, web_only: bool = False) -> list[AnyTask]:
+    subtasks = [
+        subtask
+        for subtask in group.subtasks.values()
+        if not web_only or (web_only and not subtask.cli_only)
+    ]
+    for subgroup in group.subgroups.values():
+        subtasks += get_all_subtasks(subgroup, web_only)
+    return subtasks

zrb/util/llm/tool.py

@@ -0,0 +1,63 @@
+import inspect
+from collections.abc import Callable
+from typing import Any, get_type_hints
+
+
+def callable_to_tool_schema(
+    callable_obj: Callable, name: str | None = None, description: str | None = None
+) -> dict[str, Any]:
+    """
+    Convert a callable into a tool schema dictionary by deriving the parameter schema.
+
+    :param callable_obj: The callable object (e.g., a function).
+    :param name: The name to assign to the function in the schema.
+    :param description: A description of the function.
+    :return: A dictionary representing the tool schema.
+    """
+    if not callable(callable_obj):
+        raise ValueError("Provided object is not callable")
+    # Derive name and description
+    name = name or callable_obj.__name__
+    description = description or (callable_obj.__doc__ or "").strip()
+    # Get function signature
+    sig = inspect.signature(callable_obj)
+    hints = get_type_hints(callable_obj)
+    # Build parameter schema
+    param_schema = {"type": "object", "properties": {}, "required": []}
+    for param_name, param in sig.parameters.items():
+        param_type = hints.get(param_name, str)  # Default type is string
+        param_schema["properties"][param_name] = {
+            "type": _python_type_to_json_type(param_type)
+        }
+        if param.default is inspect.Parameter.empty:
+            param_schema["required"].append(param_name)
+    return {
+        "type": "function",
+        "function": {
+            "name": name,
+            "description": description,
+            "parameters": param_schema,
+        },
+    }
+
+
+def _python_type_to_json_type(py_type):
+    """
+    Map Python types to JSON Schema types.
+    """
+    if py_type is str:
+        return "string"
+    elif py_type is int:
+        return "integer"
+    elif py_type is float:
+        return "number"
+    elif py_type is bool:
+        return "boolean"
+    elif py_type is list:
+        return "array"
+    elif py_type is dict:
+        return "object"
+    elif py_type in {None, type(None)}:
+        return "null"
+    else:
+        return "string"  # Default to string for unsupported types

zrb/util/load.py

@@ -0,0 +1,50 @@
+import importlib
+import importlib.util
+import os
+import re
+import sys
+from typing import Any
+
+pattern = re.compile("[^a-zA-Z0-9]")
+
+
+def load_zrb_init(dir_path: str | None = None):
+    if dir_path is None:
+        dir_path = os.getcwd()
+    script_path = os.path.join(dir_path, "zrb_init.py")
+    if os.path.isfile(script_path):
+        load_file(script_path)
+        return
+    new_dir_path = os.path.dirname(dir_path)
+    if new_dir_path == dir_path:
+        return
+    load_zrb_init(new_dir_path)
+
+
+def load_file(script_path: str, sys_path_index: int = 0):
+    if not os.path.isfile(script_path):
+        return
+    # Append script dir path
+    script_dir_path = os.path.dirname(script_path)
+    if script_dir_path not in sys.path:
+        sys.path.insert(sys_path_index, script_dir_path)
+    # Add script dir path to Python path
+    os.environ["PYTHONPATH"] = _get_new_python_path(script_dir_path)
+    module_name = pattern.sub("", script_path)
+    spec = importlib.util.spec_from_file_location(module_name, script_path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+
+
+def _get_new_python_path(dir_path: str) -> str:
+    current_python_path = os.getenv("PYTHONPATH")
+    if current_python_path is None or current_python_path == "":
+        return dir_path
+    if dir_path in current_python_path.split(":"):
+        return current_python_path
+    return ":".join([current_python_path, dir_path])
+
+
+def load_module(module_name: str) -> Any:
+    module = importlib.import_module(module_name)
+    return module

zrb/util/run.py

@@ -0,0 +1,9 @@
+import asyncio
+import inspect
+from typing import Any
+
+
+async def run_async(value: Any) -> Any:
+    if inspect.isawaitable(value):
+        return await value
+    return await asyncio.to_thread(lambda: value)

zrb/util/string/conversion.py

@@ -0,0 +1,92 @@
+import re
+
+NON_ALPHA_NUM = re.compile(r"[^a-zA-Z0-9]+")
+TRUE_STRS = ["true", "1", "yes", "y", "active", "on"]
+FALSE_STRS = ["false", "0", "no", "n", "inactive", "off"]
+
+
+def double_quote(input_string: str) -> str:
+    # Escape necessary characters: backslashes and double quotes
+    escaped_string = re.sub(r'([\\"])', r"\\\1", input_string)
+    # Wrap in double quotes
+    return f'"{escaped_string}"'
+
+
+def to_boolean(text: str) -> bool:
+    if text.lower() in TRUE_STRS:
+        return True
+    if text.lower() in FALSE_STRS:
+        return False
+    raise Exception(f'Cannot infer boolean value from "{text}"')
+
+
+def to_camel_case(text: str | None) -> str:
+    text = str(text) if text is not None else ""
+    pascal = to_pascal_case(text)
+    if len(pascal) == 0:
+        return pascal
+    return pascal[0].lower() + pascal[1:]
+
+
+def to_pascal_case(text: str | None) -> str:
+    text = str(text) if text is not None else ""
+    text = _to_alphanum(text)
+    return "".join(
+        [x.lower().capitalize() for x in _to_space_separated(text).split(" ")]
+    )
+
+
+def to_kebab_case(text: str | None) -> str:
+    text = str(text) if text is not None else ""
+    text = _to_alphanum(text)
+    return "-".join([x.lower() for x in _to_space_separated(text).split(" ")])
+
+
+def to_snake_case(text: str | None) -> str:
+    text = str(text) if text is not None else ""
+    text = _to_alphanum(text)
+    return "_".join([x.lower() for x in _to_space_separated(text).split(" ")])
+
+
+def _to_alphanum(text: str | None) -> str:
+    text = str(text) if text is not None else ""
+    return NON_ALPHA_NUM.sub(" ", text)
+
+
+def to_human_case(text: str | None) -> str:
+    text = str(text) if text is not None else ""
+    return " ".join(
+        [
+            x.lower() if x.upper() != x else x
+            for x in _to_space_separated(text).split(" ")
+        ]
+    )
+
+
+def _to_space_separated(text: str | None) -> str:
+    text = str(text) if text is not None else ""
+    text = text.replace("-", " ").replace("_", " ")
+    parts = text.split(" ")
+    new_parts = []
+    for part in parts:
+        new_part = ""
+        for char_index, char in enumerate(part):
+            is_first = char_index == 0
+            is_last = char_index == len(part) - 1
+            previous_char = part[char_index - 1] if not is_first else ""
+            next_char = part[char_index + 1] if not is_last else ""
+            if (
+                char.isupper()
+                and char != " "
+                and (
+                    (not is_last and next_char.islower())
+                    or (not is_first and previous_char.islower())
+                )
+            ):
+                new_part += " " + char
+                continue
+            new_part += char
+        new_part = new_part.strip(" ")
+        if new_part != "":
+            new_parts.append(new_part)
+    return " ".join(new_parts).strip(" ")

zrb/util/string/format.py

@@ -0,0 +1,9 @@
+from typing import Any
+
+
+def fstring_format(template: str, data: dict[str, Any]) -> str:
+    # Safely evaluate the template as a Python expression
+    try:
+        return eval(f'f"""{template}"""', {}, data)
+    except Exception as e:
+        raise ValueError(f"Failed to parse template: {template}: {e}")

zrb/util/string/name.py

@@ -0,0 +1,79 @@
+import random
+import string
+
+PREFIXES = [
+    "bold",
+    "calm",
+    "dark",
+    "deep",
+    "fast",
+    "firm",
+    "glad",
+    "grey",
+    "hard",
+    "high",
+    "kind",
+    "late",
+    "lean",
+    "long",
+    "loud",
+    "mild",
+    "neat",
+    "pure",
+    "rare",
+    "rich",
+    "safe",
+    "slow",
+    "soft",
+    "tall",
+    "thin",
+    "trim",
+    "vast",
+    "warm",
+    "weak",
+    "wild",
+]
+SUFFIXES = [
+    "arch",
+    "area",
+    "atom",
+    "base",
+    "beam",
+    "bell",
+    "bolt",
+    "bone",
+    "bulk",
+    "bush",
+    "cell",
+    "chip",
+    "clay",
+    "coal",
+    "coil",
+    "cone",
+    "cube",
+    "disk",
+    "dust",
+    "face",
+    "film",
+    "foam",
+    "frog",
+    "fuel",
+    "gate",
+    "gear",
+    "hall",
+    "hand",
+    "horn",
+    "leaf",
+]
+
+
+def get_random_name(
+    separator: str = "-", add_random_digit: bool = True, digit_count: int = 4
+) -> str:
+    prefix = random.choice(PREFIXES)
+    suffix = random.choice(SUFFIXES)
+    parts = [prefix, suffix]
+    if add_random_digit:
+        random_digit = "".join(random.choices(string.digits, k=digit_count))
+        parts.append(random_digit)
+    return separator.join(parts)