zrb 1.0.0a1__py3-none-any.whl → 1.0.0a3__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,135 @@
+import datetime
+import re
+
+from pydantic import BaseModel, Field, model_validator
+
+
+class TodoTask(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 read_todo_from_file(todo_file_path: str) -> list[TodoTask]:
+    with open(todo_file_path, "r") as f:
+        todo_lines = f.read().strip().split("\n")
+    todo_tasks: list[TodoTask] = []
+    for todo_line in todo_lines:
+        todo_line = todo_line.strip()
+        if todo_line == "":
+            continue
+        todo_tasks.append(parse_todo_line(todo_line))
+    todo_tasks.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_tasks
+
+
+def write_todo_to_file(todo_file_path: str, todo_task_list: list[TodoTask]):
+    with open(todo_file_path, "w") as f:
+        for todo_task in todo_task_list:
+            f.write(todo_task_to_line(todo_task))
+
+
+def parse_todo_line(line: str) -> TodoTask:
+    """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 TodoTask(
+        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: TodoTask) -> 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)

{zrb-1.0.0a1.dist-info → zrb-1.0.0a3.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: zrb
-Version: 1.0.0a1
-Summary: A Framework to Enhance Your Workflow
+Version: 1.0.0a3
+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,13 @@ 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)
+Requires-Dist: autopep8 (>=2.0.4,<3.0.0)
+Requires-Dist: black (>=24.10.0,<24.11.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: 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
@@ -88,7 +91,7 @@ To run again: zrb math add 4
 __Using Web Interface__
 
 ```bash
-zrb start-server
+zrb server start
 ```
 
 Result (you need to access `http://localhost:21213`)
@@ -111,7 +114,8 @@ pip install --pre zrb
 Alternatively, you can also use our installation script to install Zrb along with some prerequisites:
 
 ```bash
-bash -c "$(curl -fsSL https://raw.githubusercontent.com/state-alchemists/zrb/main/install.sh)"
+bash -c "$(curl -fsSL https://raw.githubusercontent.com/state-alchemists/zrb/refs/heads/1.0.0/install.sh)"
+# bash -c "$(curl -fsSL https://raw.githubusercontent.com/state-alchemists/zrb/main/install.sh)"
 ```
 
 # 🐞 Bug Report + Feature Request