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

zrb/util/cli/markdown.py

@@ -0,0 +1,12 @@
+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()

zrb/util/cli/text.py

@@ -0,0 +1,30 @@
+import os
+import subprocess
+import tempfile
+
+from zrb.util.file import read_file
+
+
+def edit_text(
+    prompt_message: str,
+    value: str,
+    editor: str = "vi",
+    extension: str = ".txt",
+) -> str:
+    with tempfile.NamedTemporaryFile(delete=False, suffix=extension) as temp_file:
+        temp_file_name = temp_file.name
+        if prompt_message.strip() != "":
+            prompt_message_eol = f"{prompt_message}\n"
+            temp_file.write(prompt_message_eol.encode())
+        # Pre-fill with default content
+        if value:
+            temp_file.write(value.encode())
+        temp_file.flush()
+        subprocess.call([editor, temp_file_name])
+        # Read the edited content
+        edited_content = read_file(temp_file_name)
+    if prompt_message.strip() != "":
+        parts = [text.strip() for text in edited_content.split(prompt_message, 1)]
+        edited_content = "\n".join(parts).lstrip()
+    os.remove(temp_file_name)
+    return edited_content

zrb/util/file.py

@@ -1,5 +1,6 @@
 import os
 import re
+from typing import Literal
 
 
 def read_file(file_path: str, replace_map: dict[str, str] = {}) -> str:
@@ -14,14 +15,21 @@ def read_file(file_path: str, replace_map: dict[str, str] = {}) -> str:
     """
     abs_file_path = os.path.abspath(os.path.expanduser(file_path))
     is_pdf = abs_file_path.lower().endswith(".pdf")
-    content = (
-        _read_pdf_file_content(abs_file_path)
-        if is_pdf
-        else _read_text_file_content(abs_file_path)
-    )
-    for key, val in replace_map.items():
-        content = content.replace(key, val)
-    return content
+    try:
+        content = (
+            _read_pdf_file_content(abs_file_path)
+            if is_pdf
+            else _read_text_file_content(abs_file_path)
+        )
+        for key, val in replace_map.items():
+            content = content.replace(key, val)
+        return content
+    except Exception:
+        import base64
+        from pathlib import Path
+
+        data = Path(abs_file_path).read_bytes()
+        return base64.b64encode(data).decode("ascii")
 
 
 def _read_text_file_content(file_path: str) -> str:
@@ -54,6 +62,8 @@ def read_file_with_line_numbers(
         The content of the file with line numbers and replacements applied.
     """
     content = read_file(file_path, replace_map)
+    if not content:
+        return ""
     lines = content.splitlines()
     numbered_lines = [f"{i + 1} | {line}" for i, line in enumerate(lines)]
     return "\n".join(numbered_lines)
@@ -71,16 +81,22 @@ def read_dir(dir_path: str) -> list[str]:
     return [f for f in os.listdir(os.path.abspath(os.path.expanduser(dir_path)))]
 
 
-def write_file(file_path: str, content: str | list[str]):
+def write_file(
+    file_path: str,
+    content: str | list[str],
+    mode: Literal["w", "wt", "tw", "a", "at", "ta", "x", "xt", "tx"] = "w",
+):
     """Writes content to a file.
 
     Args:
         file_path: The path to the file.
         content: The content to write, either a string or a list of strings.
+        mode: Writing mode (by default "w")
     """
     if isinstance(content, list):
         content = "\n".join([line for line in content if line is not None])
-    dir_path = os.path.dirname(file_path)
+    abs_file_path = os.path.abspath(os.path.expanduser(file_path))
+    dir_path = os.path.dirname(abs_file_path)
     os.makedirs(dir_path, exist_ok=True)
     should_add_eol = content.endswith("\n")
     # Remove trailing newlines, but keep one if the file originally ended up with newline
@@ -88,5 +104,5 @@ def write_file(file_path: str, content: str | list[str]):
     content = content.rstrip("\n")
     if should_add_eol:
         content += "\n"
-    with open(os.path.abspath(os.path.expanduser(file_path)), "w") as f:
+    with open(abs_file_path, mode) as f:
         f.write(content)

zrb/util/{llm/prompt.py → markdown.py}

@@ -8,7 +8,6 @@ def _adjust_markdown_headers(md: str, level_change: int) -> str:
     for line in lines:
         stripped_line = line.strip()
         fence_match = re.match(r"^([`~]{3,})", stripped_line)
-
         if fence_match:
             current_fence = fence_match.group(1)
             if (
@@ -31,7 +30,7 @@ def _adjust_markdown_headers(md: str, level_change: int) -> str:
                 new_lines.append(new_header)
             else:
                 new_lines.append(line)
-    return "\n".join(new_lines)
+    return "\n".join(new_lines).rstrip()
 
 
 def demote_markdown_headers(md: str) -> str:
@@ -42,7 +41,7 @@ def promote_markdown_headers(md: str) -> str:
     return _adjust_markdown_headers(md, level_change=-1)
 
 
-def make_prompt_section(header: str, content: str, as_code: bool = False) -> str:
+def make_markdown_section(header: str, content: str, as_code: bool = False) -> str:
     if content.strip() == "":
         return ""
     if as_code:

zrb/util/string/conversion.py

@@ -1,7 +1,7 @@
 import re
 
 NON_ALPHA_NUM = re.compile(r"[^a-zA-Z0-9]+")
-TRUE_STRS = ["true", "1", "yes", "y", "active", "on"]
+TRUE_STRS = ["true", "1", "yes", "y", "active", "on", "okay", "ok"]
 FALSE_STRS = ["false", "0", "no", "n", "inactive", "off"]
 
 

zrb/util/truncate.py

@@ -0,0 +1,23 @@
+from collections.abc import Mapping, Sequence
+from typing import Any
+
+
+def truncate_str(value: Any, limit: int):
+    # If value is a string, truncate
+    if isinstance(value, str):
+        if len(value) > limit:
+            if limit < 4:
+                return value[:limit]
+            return value[: limit - 4] + " ..."
+    # If value is a dict, process recursively
+    elif isinstance(value, Mapping):
+        return {k: truncate_str(v, limit) for k, v in value.items()}
+    # If value is a list or tuple, process recursively preserving type
+    elif isinstance(value, Sequence) and not isinstance(value, (str, bytes, bytearray)):
+        t = type(value)
+        return t(truncate_str(v, limit) for v in value)
+    # If value is a set, process recursively preserving type
+    elif isinstance(value, set):
+        return {truncate_str(v, limit) for v in value}
+    # Other types are returned unchanged
+    return value

zrb/util/yaml.py

@@ -0,0 +1,204 @@
+from typing import Any
+
+
+def yaml_dump(obj: Any, key: str = "") -> str:
+    """
+    Convert any Python object to a YAML string representation.
+
+    Args:
+        obj: Any Python object to convert to YAML
+
+    Returns:
+        str: YAML string representation of the object
+
+    Rules:
+    - Any non-first level multiline string should be rendered as block (using `|`)
+    - None values are rendered correctly (not omitted)
+    - Non-primitive/list/dict/set objects are ignored
+    """
+    import yaml
+
+    # Process the object
+    processed_obj = _sanitize_obj(obj)
+    if key:
+        key_parts = _parse_key(key)
+        obj_to_dump = _get_obj_value(processed_obj, key_parts)
+    else:
+        obj_to_dump = processed_obj
+    # Add custom representer for multiline strings
+    yaml.add_representer(str, _multiline_string_presenter)
+    # Generate YAML
+    yaml_str = yaml.dump(
+        obj_to_dump,
+        default_flow_style=False,
+        allow_unicode=True,
+        sort_keys=False,
+        explicit_end=False,
+        width=float("inf"),
+    )
+    if not isinstance(obj_to_dump, (dict, list)):
+        # PyYAML appends '...\n' (document-end) for top-level scalars.
+        # So, we remove it.
+        if yaml_str.endswith("...\n"):
+            yaml_str = yaml_str[:-4]
+    return yaml_str
+
+
+def edit_obj(obj: Any, key: str, val: str) -> Any:
+    """
+    Edit a property or subproperty of an object using YAML syntax.
+
+    Args:
+        obj: The object to edit
+        key: The key to edit, can be nested with '.' as separator
+        val: The string value to set, will be parsed as YAML
+
+    Returns:
+        Any: The modified object
+
+    Example:
+        edit({"a": {"b": 1}}, "a.b", "2") -> {"a": {"b": 2}}
+        edit({"flag": False}, "flag", "true") -> {"flag": True}
+        edit({"a": 1}, "", "2") -> 2  # Replace entire object with scalar
+        edit({"a": 1}, "", "b: 2") -> {"a": 1, "b": 2}  # Patch dict if obj is dict
+    """
+    # Parse the value using YAML rules
+    parsed_value = _load_yaml(val)
+
+    # Handle empty key - replace entire object
+    if not key:
+        if isinstance(obj, dict) and isinstance(parsed_value, dict):
+            # Patch/merge the dict values
+            return {**obj, **parsed_value}
+        # Replace entire object with parsed value
+        return parsed_value
+
+    # Split the key by dots
+    key_parts = _parse_key(key)
+    # Set the nested value
+    return _set_obj_value(obj, key_parts, parsed_value)
+
+
+def _sanitize_obj(obj: Any) -> Any:
+    """Process a value for YAML conversion."""
+    if obj is None:
+        return None
+    elif isinstance(obj, (int, float, bool, str)):
+        return obj
+    elif isinstance(obj, (list, tuple)):
+        return [_sanitize_obj(item) for item in obj if not _is_complex_obj(item)]
+    elif isinstance(obj, dict):
+        return {k: _sanitize_obj(v) for k, v in obj.items() if not _is_complex_obj(v)}
+    elif isinstance(obj, set):
+        return [
+            _sanitize_obj(item) for item in sorted(obj) if not _is_complex_obj(item)
+        ]
+    else:
+        # Ignore non-primitive/list/dict/set objects
+        return None
+
+
+def _is_complex_obj(obj: Any) -> bool:
+    return obj is not None and not isinstance(
+        obj, (int, float, bool, str, list, tuple, dict, set)
+    )
+
+
+def _multiline_string_presenter(dumper, data):
+    """Custom representer for multiline strings."""
+    if "\n" in data:
+        # Clean up the string for block style
+        lines = [line.rstrip() for line in data.splitlines()]
+        clean_data = "\n".join(lines)
+        return dumper.represent_scalar("tag:yaml.org,2002:str", clean_data, style="|")
+    return dumper.represent_scalar("tag:yaml.org,2002:str", data)
+
+
+def _parse_key(key: str) -> list[str]:
+    return key.split(".")
+
+
+def _load_yaml(value_str: str) -> Any:
+    """Parse a string value using YAML rules."""
+    import yaml
+
+    # Handle empty string explicitly
+    if value_str == "":
+        return ""
+    try:
+        # Use yaml.safe_load to parse the value
+        parsed = yaml.safe_load(value_str)
+        return parsed
+    except yaml.YAMLError:
+        # If YAML parsing fails, treat as string
+        return value_str
+
+
+def _set_obj_value(obj: Any, keys: list[str], value: Any) -> Any:
+    """Set a value in a nested structure."""
+    if not keys:
+        return value
+    current_key = keys[0]
+    remaining_keys = keys[1:]
+    if isinstance(obj, dict):
+        # Handle dictionary
+        if remaining_keys:
+            # There are more keys to traverse
+            if current_key not in obj:
+                obj[current_key] = {}
+            obj[current_key] = _set_obj_value(obj[current_key], remaining_keys, value)
+        else:
+            # This is the final key
+            obj[current_key] = value
+        return obj
+    elif isinstance(obj, list):
+        # Handle list - convert key to index
+        try:
+            index = int(current_key)
+            if 0 <= index < len(obj):
+                if remaining_keys:
+                    obj[index] = _set_obj_value(obj[index], remaining_keys, value)
+                else:
+                    obj[index] = value
+            else:
+                raise IndexError(
+                    f"Index {index} out of range for list of length {len(obj)}"
+                )
+        except ValueError:
+            raise KeyError(f"Cannot use non-integer key '{current_key}' with list")
+        return obj
+    else:
+        # Handle other types by converting to dict
+        if remaining_keys:
+            # Create nested structure
+            new_obj = {current_key: _set_obj_value({}, remaining_keys, value)}
+            return new_obj
+        else:
+            # Replace the entire object
+            return {current_key: value}
+
+
+def _get_obj_value(obj: Any, keys: list[str]) -> Any:
+    """
+    Get a value from a nested structure using a list of keys.
+    Returns None if the key path does not exist.
+    """
+    current_val = obj
+    for key in keys:
+        if isinstance(current_val, dict):
+            if key in current_val:
+                current_val = current_val[key]
+            else:
+                return None
+        elif isinstance(current_val, list):
+            try:
+                index = int(key)
+                if 0 <= index < len(current_val):
+                    current_val = current_val[index]
+                else:
+                    return None
+            except (ValueError, TypeError):
+                return None
+        else:
+            return None
+    return current_val

{zrb-1.13.1.dist-info → zrb-1.21.17.dist-info}/METADATA

@@ -1,41 +1,61 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: zrb
-Version: 1.13.1
+Version: 1.21.17
 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
 Author: Go Frendi Gunawan
 Author-email: gofrendiasgard@gmail.com
-Requires-Python: >=3.10.0,<4.0.0
+Requires-Python: >=3.11.0,<4.0.0
 Classifier: License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Provides-Extra: all
+Provides-Extra: anthropic
+Provides-Extra: bedrock
+Provides-Extra: cohere
+Provides-Extra: google
+Provides-Extra: groq
+Provides-Extra: huggingface
+Provides-Extra: mistral
 Provides-Extra: playwright
 Provides-Extra: rag
-Requires-Dist: beautifulsoup4 (>=4.13.3,<5.0.0)
-Requires-Dist: black (>=25.1.0,<25.2.0)
-Requires-Dist: chromadb (>=0.6.3,<0.7.0) ; extra == "rag" or extra == "all"
-Requires-Dist: fastapi[standard] (>=0.116.1,<0.117.0)
-Requires-Dist: isort (>=6.0.1,<6.1.0)
-Requires-Dist: libcst (>=1.7.0,<2.0.0)
-Requires-Dist: openai (>=1.86.0,<2.0.0) ; extra == "rag" or extra == "all"
-Requires-Dist: pdfplumber (>=0.11.6,<0.12.0) ; extra == "rag" or extra == "all"
-Requires-Dist: playwright (>=1.53.0,<2.0.0) ; extra == "playwright" or extra == "all"
-Requires-Dist: prompt-toolkit (>=3.0.51,<4.0.0)
+Provides-Extra: vertexai
+Requires-Dist: anthropic (>=0.70.0) ; extra == "anthropic" or extra == "all"
+Requires-Dist: beautifulsoup4 (>=4.14.2,<5.0.0)
+Requires-Dist: black (>=25.11.0,<26.0.0)
+Requires-Dist: boto3 (>=1.40.14) ; extra == "bedrock"
+Requires-Dist: chromadb (>=1.3.5,<2.0.0) ; extra == "rag" or extra == "all"
+Requires-Dist: cohere (>=5.18.0) ; extra == "cohere" or extra == "all"
+Requires-Dist: fastapi[standard] (>=0.123.9,<0.124.0)
+Requires-Dist: google-auth (>=2.36.0) ; extra == "vertexai" or extra == "all"
+Requires-Dist: google-genai (>=1.51.0) ; extra == "google" or extra == "all"
+Requires-Dist: groq (>=0.25.0) ; extra == "groq" or extra == "all"
+Requires-Dist: huggingface-hub[inference] (>=0.33.5,<1.0.0) ; extra == "huggingface"
+Requires-Dist: isort (>=7.0.0,<8.0.0)
+Requires-Dist: libcst (>=1.8.6,<2.0.0)
+Requires-Dist: markdownify (>=1.2.2,<2.0.0)
+Requires-Dist: mcp (>1.18.0)
+Requires-Dist: mistralai (>=1.9.10) ; extra == "mistral"
+Requires-Dist: openai (>=2.8.0)
+Requires-Dist: pdfplumber (>=0.11.7,<0.12.0)
+Requires-Dist: playwright (>=1.56.0,<2.0.0) ; extra == "playwright" or extra == "all"
+Requires-Dist: prompt-toolkit (>=3)
 Requires-Dist: psutil (>=7.0.0,<8.0.0)
-Requires-Dist: pydantic-ai (>=0.4.5,<0.5.0)
+Requires-Dist: pydantic-ai-slim (>=1.27.0,<1.28.0)
 Requires-Dist: pyjwt (>=2.10.1,<3.0.0)
 Requires-Dist: python-dotenv (>=1.1.1,<2.0.0)
-Requires-Dist: python-jose[cryptography] (>=3.4.0,<4.0.0)
-Requires-Dist: requests (>=2.32.4,<3.0.0)
-Requires-Dist: rich (>=14.0.0,<15.0.0)
-Requires-Dist: tiktoken (>=0.8.0,<0.9.0)
+Requires-Dist: python-jose[cryptography] (>=3.5.0,<4.0.0)
+Requires-Dist: pyyaml (>=6.0.3,<7.0.0)
+Requires-Dist: requests (>=2.32.5,<3.0.0)
+Requires-Dist: rich (>=13)
+Requires-Dist: tiktoken (>=0.12.0,<0.13.0)
 Requires-Dist: ulid-py (>=1.1.0,<2.0.0)
 Project-URL: Documentation, https://github.com/state-alchemists/zrb
+Project-URL: Homepage, https://github.com/state-alchemists/zrb
 Project-URL: Repository, https://github.com/state-alchemists/zrb
 Description-Content-Type: text/markdown