zrb 1.0.0a2__py3-none-any.whl → 1.0.0a4__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

@@ -1,5 +1,5 @@
-from ..group.any_group import AnyGroup
-from ..task.any_task import AnyTask
+from zrb.group.any_group import AnyGroup
+from zrb.task.any_task import AnyTask
 
 
 class NodeNotFoundError(ValueError):

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/string/conversion.py

@@ -5,6 +5,13 @@ 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

zrb/util/todo.py

@@ -0,0 +1,259 @@
+import datetime
+import re
+
+from pydantic import BaseModel, Field, model_validator
+
+from zrb.util.cli.style import (
+    stylize_bold_green,
+    stylize_cyan,
+    stylize_magenta,
+    stylize_yellow,
+)
+from zrb.util.string.name import get_random_name
+
+
+class TodoTaskModel(BaseModel):
+    priority: str | None = Field("D", pattern=r"^[A-Z]$")  # Priority like A, B, ...
+    completed: bool = False  # True if completed, False otherwise
+    description: str  # Main task description
+    projects: list[str] = []  # List of projects (e.g., +Project)
+    contexts: list[str] = []  # List of contexts (e.g., @Context)
+    keyval: dict[str, str] = {}  # Special key (e.g., due:2016-05-30)
+    creation_date: datetime.date | None = None  # Creation date
+    completion_date: datetime.date | None = None  # Completion date
+
+    @model_validator(mode="before")
+    def validate_dates(cls, values):
+        completion_date = values.get("completion_date")
+        creation_date = values.get("creation_date")
+        if completion_date and not creation_date:
+            raise ValueError(
+                "creation_date must be specified if completion_date is set."
+            )
+        return values
+
+
+TODO_TXT_PATTERN = re.compile(
+    r"^(?P<status>x)?\s*"  # Optional completion mark ('x')
+    r"(?:\((?P<priority>[A-Z])\)\s+)?"  # Optional priority (e.g., '(A)')
+    r"(?P<date1>\d{4}-\d{2}-\d{2})?\s*"  # Optional first date
+    r"(?P<date2>\d{4}-\d{2}-\d{2})?\s*"  # Optional second date
+    r"(?P<description>.*?)$"  # Main description
+)
+
+
+def cascade_todo_task(todo_task: TodoTaskModel):
+    if todo_task.creation_date is None:
+        todo_task.creation_date = datetime.date.today()
+    if "id" not in todo_task.keyval:
+        todo_task.keyval["id"] = get_random_name()
+    return todo_task
+
+
+def select_todo_task(
+    todo_list: list[TodoTaskModel], keyword: str
+) -> TodoTaskModel | None:
+    for todo_task in todo_list:
+        id = todo_task.keyval.get("id", "")
+        if keyword.lower().strip() == id.lower().strip():
+            return todo_task
+    for todo_task in todo_list:
+        description = todo_task.description
+        if keyword.lower().strip() == description.lower().strip():
+            return todo_task
+    for todo_task in todo_list:
+        id = todo_task.keyval.get("id", "")
+        if keyword.lower().strip() in id.lower().strip():
+            return todo_task
+    for todo_task in todo_list:
+        description = todo_task.description
+        if keyword.lower().strip() in description.lower().strip():
+            return todo_task
+    return None
+
+
+def load_todo_list(todo_file_path: str) -> list[TodoTaskModel]:
+    with open(todo_file_path, "r") as f:
+        todo_lines = f.read().strip().split("\n")
+    todo_list: list[TodoTaskModel] = []
+    for todo_line in todo_lines:
+        todo_line = todo_line.strip()
+        if todo_line == "":
+            continue
+        todo_list.append(line_to_todo_task(todo_line))
+    todo_list.sort(
+        key=lambda task: (
+            task.completed,
+            task.priority if task.priority else "Z",
+            task.projects[0] if task.projects else "zzz",
+            task.creation_date if task.creation_date else datetime.date.max,
+        )
+    )
+    return todo_list
+
+
+def save_todo_list(todo_file_path: str, todo_list: list[TodoTaskModel]):
+    with open(todo_file_path, "w") as f:
+        for todo_task in todo_list:
+            f.write(todo_task_to_line(todo_task) + "\n")
+
+
+def line_to_todo_task(line: str) -> TodoTaskModel:
+    """Parses a single todo.txt line into a TodoTask model."""
+    match = TODO_TXT_PATTERN.match(line)
+    if not match:
+        raise ValueError(f"Invalid todo.txt line: {line}")
+    groups = match.groupdict()
+    # Extract completion status
+    is_completed = groups["status"] == "x"
+    # Extract dates
+    date1 = _parse_date(groups["date1"])
+    date2 = _parse_date(groups["date2"])
+    # Determine creation_date and completion_date
+    completion_date, creation_date = None, None
+    if date2 is None:
+        creation_date = date1
+    else:
+        completion_date = date1
+        creation_date = date2
+    # Extract and clean description
+    raw_description = groups["description"] or ""
+    projects = re.findall(r"\+(\S+)", raw_description)
+    contexts = re.findall(r"@(\S+)", raw_description)
+    keyval = {}
+    for keyval_str in re.findall(r"(\S+:\S+)", raw_description):
+        key, val = keyval_str.split(":", 1)
+        keyval[key] = val
+    description = re.sub(r"\s*\+\S+|\s*@\S+|\s*\S+:\S+", "", raw_description).strip()
+    return TodoTaskModel(
+        priority=groups["priority"],
+        completed=is_completed,
+        description=description,
+        projects=projects,
+        contexts=contexts,
+        keyval=keyval,
+        creation_date=creation_date,
+        completion_date=completion_date,
+    )
+
+
+def _parse_date(date_str: str | None) -> datetime.date | None:
+    """Parses a date string in the format YYYY-MM-DD."""
+    if date_str:
+        return datetime.date.fromisoformat(date_str)
+    return None
+
+
+def todo_task_to_line(task: TodoTaskModel) -> str:
+    """Converts a TodoTask instance back into a todo.txt formatted line."""
+    parts = []
+    # Add completion mark if task is completed
+    if task.completed:
+        parts.append("x")
+    # Add priority if present
+    if task.priority:
+        parts.append(f"({task.priority})")
+    # Add completion and creation dates if present
+    if task.completion_date:
+        parts.append(task.completion_date.isoformat())
+    if task.creation_date:
+        parts.append(task.creation_date.isoformat())
+    # Add description
+    parts.append(task.description)
+    # Append projects
+    for project in task.projects:
+        parts.append(f"+{project}")
+    # Append contexts
+    for context in task.contexts:
+        parts.append(f"@{context}")
+    # Append keyval
+    for key, val in task.keyval.items():
+        parts.append(f"{key}:{val}")
+    # Join all parts with a space
+    return " ".join(parts)
+
+
+def get_visual_todo_list(todo_list: list[TodoTaskModel]) -> str:
+    if len(todo_list) == 0:
+        return "\n".join(["", "  Empty todo list... 🌵🦖", ""])
+    max_desc_name_length = max(len(todo_task.description) for todo_task in todo_list)
+    if max_desc_name_length < len("DESCRIPTION"):
+        max_desc_name_length = len("DESCRIPTION")
+    # Headers
+    results = [
+        stylize_bold_green(
+            "  ".join(
+                [
+                    "".ljust(3),  # priority
+                    "".ljust(3),  # completed
+                    "COMPLETED AT".rjust(14),  # completed date
+                    "CREATED AT".rjust(14),  # completed date
+                    "DESCRIPTION".ljust(max_desc_name_length),
+                    "PROJECT/CONTEXT/OTHERS",
+                ]
+            )
+        )
+    ]
+    for todo_task in todo_list:
+        completed = "[x]" if todo_task.completed else "[ ]"
+        priority = "   " if todo_task.priority is None else f"({todo_task.priority})"
+        completion_date = stylize_yellow(_date_to_str(todo_task.completion_date))
+        creation_date = stylize_cyan(_date_to_str(todo_task.creation_date))
+        description = todo_task.description.ljust(max_desc_name_length)
+        additions = ", ".join(
+            [stylize_yellow(f"+{project}") for project in todo_task.projects]
+            + [stylize_cyan(f"@{context}") for context in todo_task.contexts]
+            + [stylize_magenta(f"{key}:{val}") for key, val in todo_task.keyval.items()]
+        )
+        results.append(
+            "  ".join(
+                [
+                    completed,
+                    priority,
+                    completion_date,
+                    creation_date,
+                    description,
+                    additions,
+                ]
+            )
+        )
+    return "\n".join(results)
+
+
+def _date_to_str(date: datetime.date | None) -> str:
+    if date is None:
+        return "".ljust(14)
+    return date.strftime("%a %Y-%m-%d")
+
+
+def add_durations(duration1: str, duration2: str) -> str:
+    total_seconds = _parse_duration(duration1) + _parse_duration(duration2)
+    # Format and return the result
+    return _format_duration(total_seconds)
+
+
+def _parse_duration(duration: str) -> int:
+    """Parse a duration string into total seconds."""
+    units = {"M": 2592000, "w": 604800, "d": 86400, "h": 3600, "m": 60, "s": 1}
+    total_seconds = 0
+    match = re.findall(r"(\d+)([Mwdhms])", duration)
+    for value, unit in match:
+        total_seconds += int(value) * units[unit]
+    return total_seconds
+
+
+def _format_duration(total_seconds: int) -> str:
+    """Format total seconds into a duration string."""
+    units = [
+        ("w", 604800),  # 7 days in a week
+        ("d", 86400),  # 24 hours in a day
+        ("h", 3600),  # 60 minutes in an hour
+        ("m", 60),  # 60 seconds in a minute
+        ("s", 1),  # seconds
+    ]
+    result = []
+    for unit, value_in_seconds in units:
+        if total_seconds >= value_in_seconds:
+            amount, total_seconds = divmod(total_seconds, value_in_seconds)
+            result.append(f"{amount}{unit}")
+    return "".join(result) if result else "0s"

{zrb-1.0.0a2.dist-info → zrb-1.0.0a4.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: zrb
-Version: 1.0.0a2
-Summary: A Framework to Enhance Your Workflow
+Version: 1.0.0a4
+Summary: Your Automation Powerhouse
 Home-page: https://github.com/state-alchemists/zrb
 License: AGPL-3.0-or-later
 Keywords: Automation,Task Runner,Code Generator,Monorepo,Low Code
@@ -13,10 +13,18 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: autopep8 (>=2.0.4,<2.1.0)
-Requires-Dist: python-dotenv (>=1.0.1,<1.1.0)
+Provides-Extra: rag
+Requires-Dist: autopep8 (>=2.0.4,<3.0.0)
+Requires-Dist: beautifulsoup4 (>=4.12.3,<5.0.0)
+Requires-Dist: black (>=24.10.0,<24.11.0)
+Requires-Dist: chromadb (>=0.5.20,<0.6.0) ; extra == "rag"
+Requires-Dist: fastapi[standard] (>=0.115.5,<0.116.0)
+Requires-Dist: isort (>=5.13.2,<5.14.0)
+Requires-Dist: libcst (>=1.5.0,<2.0.0)
+Requires-Dist: litellm (>=1.52.12,<2.0.0)
+Requires-Dist: pdfplumber (>=0.11.4,<0.12.0) ; extra == "rag"
+Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
 Requires-Dist: requests (>=2.32.3,<3.0.0)
-Requires-Dist: tomlkit (>=0.12.4,<0.13.0)
 Project-URL: Documentation, https://github.com/state-alchemists/zrb
 Project-URL: Repository, https://github.com/state-alchemists/zrb
 Description-Content-Type: text/markdown