zrb 1.15.3__py3-none-any.whl → 1.21.29__py3-none-any.whl

zrb/util/attr.py

@@ -9,52 +9,59 @@ from zrb.attr.type import (
     StrDictAttr,
     StrListAttr,
 )
+from zrb.context.any_context import AnyContext
 from zrb.context.any_shared_context import AnySharedContext
 from zrb.util.string.conversion import to_boolean
 
 
 def get_str_list_attr(
-    shared_ctx: AnySharedContext, attr: StrListAttr | None, auto_render: bool = True
+    ctx: AnyContext | AnySharedContext,
+    attr: StrListAttr | None,
+    auto_render: bool = True,
 ) -> list[str]:
     """
     Retrieve a list of strings from shared context attributes.
 
     Args:
-        shared_ctx (AnySharedContext): The shared context object.
+        ctx (AnyContext): The shared context object.
         attr (StrListAttr | None): The string list attribute to retrieve.
         auto_render (bool): Whether to auto-render the attribute values.
 
     Returns:
         list[str]: A list of string attributes.
     """
+    if attr is None:
+        return []
     if callable(attr):
-        return attr(shared_ctx)
-    return {get_str_attr(shared_ctx, val, "", auto_render) for val in attr}
+        return attr(ctx)
+    return [get_str_attr(ctx, val, "", auto_render) for val in attr]
 
 
 def get_str_dict_attr(
-    shared_ctx: AnySharedContext, attr: StrDictAttr | None, auto_render: bool = True
+    ctx: AnyContext | AnySharedContext,
+    attr: StrDictAttr | None,
+    auto_render: bool = True,
 ) -> dict[str, Any]:
     """
     Retrieve a dictionary of strings from shared context attributes.
 
     Args:
-        shared_ctx (AnySharedContext): The shared context object.
+        ctx (AnyContext): The shared context object.
         attr (StrDictAttr | None): The string dictionary attribute to retrieve.
         auto_render (bool): Whether to auto-render the attribute values.
 
     Returns:
         dict[str, Any]: A dictionary of string attributes.
     """
+    if attr is None:
+        return {}
     if callable(attr):
-        return attr(shared_ctx)
-    return {
-        key: get_str_attr(shared_ctx, val, "", auto_render) for key, val in attr.items()
-    }
+        return attr(ctx)
+    return {key: get_str_attr(ctx, val, "", auto_render) for key, val in attr.items()}
 
 
 def get_str_attr(
-    shared_ctx: AnySharedContext,
+    ctx: AnyContext | AnySharedContext,
     attr: StrAttr | None,
     default: StrAttr = "",
     auto_render: bool = True,
@@ -63,7 +70,7 @@ def get_str_attr(
     Retrieve a string from shared context attributes.
 
     Args:
-        shared_ctx (AnySharedContext): The shared context object.
+        ctx (AnyContext): The shared context object.
         attr (StrAttr | None): The string attribute to retrieve.
         default (StrAttr): The default value if the attribute is None.
         auto_render (bool): Whether to auto-render the attribute value.
@@ -71,14 +78,16 @@ def get_str_attr(
     Returns:
         str: The string attribute value.
     """
-    val = get_attr(shared_ctx, attr, default, auto_render)
-    if not isinstance(val, str):
-        return str(val)
-    return val
+    val = get_attr(ctx, attr, default, auto_render)
+    if isinstance(val, str):
+        return val
+    if val is None:
+        return ""
+    return str(val)
 
 
 def get_bool_attr(
-    shared_ctx: AnySharedContext,
+    ctx: AnyContext | AnySharedContext,
     attr: BoolAttr | None,
     default: BoolAttr = False,
     auto_render: bool = True,
@@ -87,7 +96,7 @@ def get_bool_attr(
     Retrieve a boolean from shared context attributes.
 
     Args:
-        shared_ctx (AnySharedContext): The shared context object.
+        ctx (AnyContext): The shared context object.
         attr (BoolAttr | None): The boolean attribute to retrieve.
         default (BoolAttr): The default value if the attribute is None.
         auto_render (bool): Whether to auto-render the attribute value if it's a string.
@@ -95,14 +104,16 @@ def get_bool_attr(
     Returns:
         bool: The boolean attribute value.
     """
-    val = get_attr(shared_ctx, attr, default, auto_render)
-    if isinstance(val, str):
-        return to_boolean(val)
-    return val
+    val = get_attr(ctx, attr, default, auto_render)
+    if isinstance(val, bool):
+        return val
+    if val is None:
+        return False
+    return to_boolean(val)
 
 
 def get_int_attr(
-    shared_ctx: AnySharedContext,
+    ctx: AnyContext | AnySharedContext,
     attr: IntAttr | None,
     default: IntAttr = 0,
     auto_render: bool = True,
@@ -111,7 +122,7 @@ def get_int_attr(
     Retrieve an integer from shared context attributes.
 
     Args:
-        shared_ctx (AnySharedContext): The shared context object.
+        ctx (AnyContext): The shared context object.
         attr (IntAttr | None): The integer attribute to retrieve.
         default (IntAttr): The default value if the attribute is None.
         auto_render (bool): Whether to auto-render the attribute value if it's a string.
@@ -119,14 +130,16 @@ def get_int_attr(
     Returns:
         int: The integer attribute value.
     """
-    val = get_attr(shared_ctx, attr, default, auto_render)
-    if isinstance(val, str):
-        return int(val)
-    return val
+    val = get_attr(ctx, attr, default, auto_render)
+    if isinstance(val, int):
+        return val
+    if val is None:
+        return 0
+    return int(val)
 
 
 def get_float_attr(
-    shared_ctx: AnySharedContext,
+    ctx: AnyContext | AnySharedContext,
     attr: FloatAttr | None,
     default: FloatAttr = 0.0,
     auto_render: bool = True,
@@ -135,7 +148,7 @@ def get_float_attr(
     Retrieve a float from shared context attributes.
 
     Args:
-        shared_ctx (AnySharedContext): The shared context object.
+        ctx (AnyContext): The shared context object.
         attr (FloatAttr | None): The float attribute to retrieve.
         default (FloatAttr): The default value if the attribute is None.
         auto_render (bool): Whether to auto-render the attribute value if it's a string.
@@ -143,14 +156,16 @@ def get_float_attr(
     Returns:
         float | None: The float attribute value.
     """
-    val = get_attr(shared_ctx, attr, default, auto_render)
-    if isinstance(val, str):
-        return float(val)
-    return val
+    val = get_attr(ctx, attr, default, auto_render)
+    if isinstance(val, (int, float)):
+        return val
+    if val is None:
+        return 0.0
+    return float(val)
 
 
 def get_attr(
-    shared_ctx: AnySharedContext,
+    ctx: AnyContext | AnySharedContext,
     attr: AnyAttr,
     default: AnyAttr,
     auto_render: bool = True,
@@ -159,7 +174,7 @@ def get_attr(
     Retrieve an attribute value from shared context, handling callables and rendering.
 
     Args:
-        shared_ctx (AnySharedContext): The shared context object.
+        ctx (AnyContext): The shared context object.
         attr (AnyAttr): The attribute to retrieve. Can be a value, a callable,
             or a string to render.
         default (AnyAttr): The default value if the attribute is None.
@@ -170,10 +185,10 @@ def get_attr(
     """
     if attr is None:
         if callable(default):
-            return default(shared_ctx)
+            return default(ctx)
         return default
     if callable(attr):
-        return attr(shared_ctx)
+        return attr(ctx)
     if isinstance(attr, str) and auto_render:
-        return shared_ctx.render(attr)
+        return ctx.render(attr)
     return attr

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:
@@ -61,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)
@@ -78,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
@@ -95,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/git.py

@@ -131,7 +131,7 @@ async def get_branches(
         Exception: If the git command returns a non-zero exit code.
     """
     cmd_result, exit_code = await run_command(
-        cmd=["git", "rev-parse", "--abbrev-ref", "HEAD"],
+        cmd=["git", "branch"],
         cwd=repo_dir,
         print_method=print_method,
     )
@@ -160,7 +160,7 @@ async def delete_branch(
         Exception: If the git command returns a non-zero exit code.
     """
     cmd_result, exit_code = await run_command(
-        cmd=["git", "branch", "-D", branch_name],
+        cmd=["git", "branch", "-d", branch_name],
         cwd=repo_dir,
         print_method=print_method,
     )

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/xcom/xcom.py

@@ -34,6 +34,16 @@ class Xcom(deque):
         else:
             raise IndexError("Xcom is empty")
 
+    def get(self, default_value: Any = None) -> Any:
+        if len(self) > 0:
+            return self[0]
+        return default_value
+
+    def set(self, new_value: Any):
+        self.push(new_value)
+        while len(self) > 1:
+            self.pop()
+
     def add_push_callback(self, callback: Callable[[], Any]):
         if not hasattr(self, "push_callbacks"):
             self.push_callbacks: list[Callable[[], Any]] = []