zrb 1.8.10__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/callable.py

@@ -0,0 +1,23 @@
+from types import BuiltinMethodType, MethodType
+
+
+def get_callable_name(obj):
+    import functools
+    import inspect
+
+    # 1. Unwrap decorated functions
+    obj = inspect.unwrap(obj, stop=lambda f: not hasattr(f, "__wrapped__"))
+    # 2. functools.partial – delegate to the wrapped function
+    if isinstance(obj, functools.partial):
+        return get_callable_name(obj.func)
+    # 3. Plain functions, built‑ins, methods
+    if hasattr(obj, "__name__"):
+        return obj.__name__
+    # 4. Bound or unbound methods of a class
+    if isinstance(obj, (MethodType, BuiltinMethodType)):
+        return obj.__func__.__name__
+    # 5. Instances of classes defining __call__
+    if callable(obj):
+        return type(obj).__name__
+    # 6. Fallback
+    return repr(obj)

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:
@@ -32,8 +40,10 @@ def _read_text_file_content(file_path: str) -> str:
 
 def _read_pdf_file_content(file_path: str) -> str:
     import pdfplumber
+    from pdfplumber.pdf import PDF
 
     with pdfplumber.open(file_path) as pdf:
+        pdf: PDF
         return "\n".join(
             page.extract_text() for page in pdf.pages if page.extract_text()
         )
@@ -52,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)
@@ -69,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
@@ -86,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

@@ -1,16 +1,11 @@
 import os
 from collections.abc import Callable
-from typing import Any
-
-from pydantic import BaseModel
+from typing import TYPE_CHECKING, Any
 
 from zrb.util.cmd.command import run_command
 
-
-class DiffResult(BaseModel):
-    created: list[str]
-    removed: list[str]
-    updated: list[str]
+if TYPE_CHECKING:
+    from zrb.util.git_diff_model import DiffResult
 
 
 async def get_diff(
@@ -18,7 +13,7 @@ async def get_diff(
     source_commit: str,
     current_commit: str,
     print_method: Callable[..., Any] = print,
-) -> DiffResult:
+) -> "DiffResult":
     """
     Get the difference between two commits in a Git repository.
 
@@ -34,6 +29,8 @@ async def get_diff(
     Raises:
         Exception: If the git command returns a non-zero exit code.
     """
+    from zrb.util.git_diff_model import DiffResult
+
     cmd_result, exit_code = await run_command(
         cmd=["git", "diff", source_commit, current_commit],
         cwd=repo_dir,
@@ -134,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,
     )
@@ -163,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/git_diff_model.py

@@ -0,0 +1,10 @@
+class DiffResult:
+    def __init__(
+        self,
+        created: list[str] | None = None,
+        removed: list[str] | None = None,
+        updated: list[str] | None = None,
+    ):
+        self.created = created if created is not None else []
+        self.removed = removed if removed is not None else []
+        self.updated = updated if updated is not None else []

zrb/util/git_subtree.py

@@ -1,24 +1,15 @@
 import os
 from collections.abc import Callable
-from typing import Any
-
-from pydantic import BaseModel
+from typing import TYPE_CHECKING, Any
 
 from zrb.util.cmd.command import run_command
 from zrb.util.file import read_file, write_file
 
+if TYPE_CHECKING:
+    from zrb.util.git_subtree_model import SubTreeConfig
 
-class SingleSubTreeConfig(BaseModel):
-    repo_url: str
-    branch: str
-    prefix: str
-
-
-class SubTreeConfig(BaseModel):
-    data: dict[str, SingleSubTreeConfig]
 
-
-def load_config(repo_dir: str) -> SubTreeConfig:
+def load_config(repo_dir: str):
     """
     Load the subtree configuration from subtrees.json.
 
@@ -28,13 +19,15 @@ def load_config(repo_dir: str) -> SubTreeConfig:
     Returns:
         SubTreeConfig: The loaded subtree configuration.
     """
+    from zrb.util.git_subtree_model import SubTreeConfig
+
     file_path = os.path.join(repo_dir, "subtrees.json")
     if not os.path.exists(file_path):
         return SubTreeConfig(data={})
     return SubTreeConfig.model_validate_json(read_file(file_path))
 
 
-def save_config(repo_dir: str, config: SubTreeConfig):
+def save_config(repo_dir: str, config: "SubTreeConfig"):
     """
     Save the subtree configuration to subtrees.json.
 
@@ -70,6 +63,8 @@ async def add_subtree(
             name already exists.
         Exception: If the git command returns a non-zero exit code.
     """
+    from zrb.util.git_subtree_model import SingleSubTreeConfig
+
     config = load_config(repo_dir)
     if os.path.isdir(prefix):
         raise ValueError(f"Directory exists: {prefix}")

zrb/util/git_subtree_model.py

@@ -0,0 +1,32 @@
+import json
+from typing import Any
+
+
+class SingleSubTreeConfig:
+    def __init__(self, repo_url: str, branch: str, prefix: str):
+        self.repo_url = repo_url
+        self.branch = branch
+        self.prefix = prefix
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "repo_url": self.repo_url,
+            "branch": self.branch,
+            "prefix": self.prefix,
+        }
+
+    def model_dump_json(self, indent: int = 2) -> str:
+        return json.dumps(self.to_dict(), indent=indent)
+
+
+class SubTreeConfig:
+    def __init__(self, data: dict[str, SingleSubTreeConfig]):
+        self.data = data
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "data": {k: self.data[k].to_dict() for k in self.data},
+        }
+
+    def model_dump_json(self, indent: int = 2) -> str:
+        return json.dumps(self.to_dict(), indent=indent)

zrb/util/init_path.py

@@ -1,6 +1,6 @@
 import os
 
-from zrb.config import CFG
+from zrb.config.config import CFG
 
 
 def get_init_path_list() -> list[str]:

zrb/util/markdown.py

@@ -0,0 +1,62 @@
+import re
+
+
+def _adjust_markdown_headers(md: str, level_change: int) -> str:
+    lines = md.split("\n")
+    new_lines = []
+    fence_stack = []
+    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 (
+                fence_stack
+                and fence_stack[-1][0] == current_fence[0]
+                and len(current_fence) >= len(fence_stack[-1])
+            ):
+                fence_stack.pop()
+            else:
+                fence_stack.append(current_fence)
+            new_lines.append(line)
+        elif fence_stack:
+            new_lines.append(line)
+        else:
+            match = re.match(r"^(#{1,6})(\s)", line)
+            if match:
+                current_level = len(match.group(1))
+                new_level = max(1, current_level + level_change)
+                new_header = "#" * new_level + line[current_level:]
+                new_lines.append(new_header)
+            else:
+                new_lines.append(line)
+    return "\n".join(new_lines).rstrip()
+
+
+def demote_markdown_headers(md: str) -> str:
+    return _adjust_markdown_headers(md, level_change=1)
+
+
+def promote_markdown_headers(md: str) -> str:
+    return _adjust_markdown_headers(md, level_change=-1)
+
+
+def make_markdown_section(header: str, content: str, as_code: bool = False) -> str:
+    if content.strip() == "":
+        return ""
+    if as_code:
+        # Find the longest sequence of backticks in the content
+        longest_backtick_sequence = 0
+        # Use finditer to find all occurrences of backticks
+        for match in re.finditer(r"`+", content):
+            longest_backtick_sequence = max(
+                longest_backtick_sequence, len(match.group(0))
+            )
+
+        # The fence should be one longer than the longest sequence found
+        fence_len = 4
+        if longest_backtick_sequence >= fence_len:
+            fence_len = longest_backtick_sequence + 1
+        fence = "`" * fence_len
+        return f"# {header}\n{fence}\n{content.strip()}\n{fence}\n"
+    return f"# {header}\n{demote_markdown_headers(content.strip())}\n"

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"]
 
 
@@ -178,7 +178,7 @@ def pluralize(noun: str) -> str:
     if noun.lower() in irregulars:
         return irregulars[noun.lower()]
     # Handle words ending in 'y' preceded by a consonant
-    if noun.endswith("y") and not re.match(r"[aeiou]y$", noun):
+    if noun.endswith("y") and not re.match(r".*[aeiou]y$", noun, re.IGNORECASE):
         return re.sub(r"y$", "ies", noun)
     # Handle words ending in 's', 'x', 'z', 'ch', or 'sh'
     if re.search(r"(s|x|z|ch|sh)$", noun):