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

zrb/util/todo.py

@@ -1,8 +1,7 @@
 import datetime
 import re
 import shutil
-
-from pydantic import BaseModel, Field, model_validator
+from typing import TYPE_CHECKING
 
 from zrb.util.cli.style import (
     stylize_bold_yellow,
@@ -14,6 +13,9 @@ from zrb.util.cli.style import (
 from zrb.util.file import read_file, write_file
 from zrb.util.string.name import get_random_name
 
+if TYPE_CHECKING:
+    from zrb.util.todo_model import TodoTaskModel
+
 _DATE_TIME_STR_WIDTH = 14
 _MAX_DESCRIPTION_WIDTH = 70
 _PRIORITY_WIDTH = 3
@@ -23,43 +25,6 @@ _CREATED_AT_WIDTH = _DATE_TIME_STR_WIDTH
 _GAP_WIDTH = 2
 
 
-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
-
-    def get_additional_info_length(self):
-        """
-        Calculate the length of the additional information string (projects, contexts, keyval).
-
-        Returns:
-            int: The length of the combined additional information string.
-        """
-        results = []
-        for project in self.projects:
-            results.append(f"@{project}")
-        for context in self.contexts:
-            results.append(f"+{context}")
-        for key, val in self.keyval.items():
-            results.append(f"{key}:{val}")
-        return len(", ".join(results))
-
-
 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)')
@@ -69,7 +34,7 @@ TODO_TXT_PATTERN = re.compile(
 )
 
 
-def cascade_todo_task(todo_task: TodoTaskModel):
+def cascade_todo_task(todo_task: "TodoTaskModel"):
     """
     Populate default values for a TodoTaskModel if they are missing.
 
@@ -87,8 +52,8 @@ def cascade_todo_task(todo_task: TodoTaskModel):
 
 
 def select_todo_task(
-    todo_list: list[TodoTaskModel], keyword: str
-) -> TodoTaskModel | None:
+    todo_list: list["TodoTaskModel"], keyword: str
+) -> "TodoTaskModel | None":
     """
     Select a todo task from a list based on a keyword matching ID or description.
 
@@ -118,7 +83,7 @@ def select_todo_task(
     return None
 
 
-def load_todo_list(todo_file_path: str) -> list[TodoTaskModel]:
+def load_todo_list(todo_file_path: str) -> list["TodoTaskModel"]:
     """
     Load a list of todo tasks from a todo.txt file.
 
@@ -129,7 +94,7 @@ def load_todo_list(todo_file_path: str) -> list[TodoTaskModel]:
         list[TodoTaskModel]: A sorted list of todo tasks.
     """
     todo_lines = read_file(todo_file_path).strip().split("\n")
-    todo_list: list[TodoTaskModel] = []
+    todo_list: list["TodoTaskModel"] = []
     for todo_line in todo_lines:
         todo_line = todo_line.strip()
         if todo_line == "":
@@ -147,7 +112,7 @@ def load_todo_list(todo_file_path: str) -> list[TodoTaskModel]:
     return todo_list
 
 
-def save_todo_list(todo_file_path: str, todo_list: list[TodoTaskModel]):
+def save_todo_list(todo_file_path: str, todo_list: list["TodoTaskModel"]):
     """
     Save a list of todo tasks to a todo.txt file.
 
@@ -160,8 +125,10 @@ def save_todo_list(todo_file_path: str, todo_list: list[TodoTaskModel]):
     )
 
 
-def line_to_todo_task(line: str) -> TodoTaskModel:
+def line_to_todo_task(line: str) -> "TodoTaskModel":
     """Parses a single todo.txt line into a TodoTask model."""
+    from zrb.util.todo_model import TodoTaskModel
+
     match = TODO_TXT_PATTERN.match(line)
     if not match:
         raise ValueError(f"Invalid todo.txt line: {line}")
@@ -214,7 +181,7 @@ def _parse_date(date_str: str | None) -> datetime.date | None:
     return None
 
 
-def todo_task_to_line(task: TodoTaskModel) -> str:
+def todo_task_to_line(task: "TodoTaskModel") -> str:
     """
     Converts a TodoTask instance back into a todo.txt formatted line.
 
@@ -251,7 +218,7 @@ def todo_task_to_line(task: TodoTaskModel) -> str:
     return " ".join(parts)
 
 
-def get_visual_todo_list(todo_list: list[TodoTaskModel], filter: str) -> str:
+def get_visual_todo_list(todo_list: list["TodoTaskModel"], filter: str) -> str:
     """
     Generate a visual representation of a filtered todo list.
 
@@ -352,7 +319,7 @@ def get_visual_todo_line(
     terminal_width: int,
     max_desc_length: int,
     max_additional_info_length: int,
-    todo_task: TodoTaskModel,
+    todo_task: "TodoTaskModel",
 ) -> str:
     """
     Generate a single line string for a todo task in the visual todo list.
@@ -489,7 +456,7 @@ def _get_minimum_width(field_widths: list[int]) -> int:
 
 
 def get_visual_todo_card(
-    todo_task: TodoTaskModel, log_work_list: list[dict[str, str]]
+    todo_task: "TodoTaskModel", log_work_list: list[dict[str, str]]
 ) -> str:
     """
     Generate a visual card representation of a todo task with log work.

zrb/util/todo_model.py

@@ -0,0 +1,46 @@
+import datetime
+import re
+
+
+class TodoTaskModel:
+    def __init__(
+        self,
+        description: str,
+        priority: str | None = "D",
+        completed: bool = False,
+        projects: list[str] | None = None,
+        contexts: list[str] | None = None,
+        keyval: dict[str, str] | None = None,
+        creation_date: datetime.date | None = None,
+        completion_date: datetime.date | None = None,
+    ):
+        if priority is not None and not re.match(r"^[A-Z]$", priority):
+            raise ValueError("Invalid priority format")
+        if completion_date and not creation_date:
+            raise ValueError(
+                "creation_date must be specified if completion_date is set."
+            )
+        self.priority = priority
+        self.completed = completed
+        self.description = description
+        self.projects = projects if projects is not None else []
+        self.contexts = contexts if contexts is not None else []
+        self.keyval = keyval if keyval is not None else {}
+        self.creation_date = creation_date
+        self.completion_date = completion_date
+
+    def get_additional_info_length(self):
+        """
+        Calculate the length of the additional information string (projects, contexts, keyval).
+
+        Returns:
+            int: The length of the combined additional information string.
+        """
+        results = []
+        for project in self.projects:
+            results.append(f"@{project}")
+        for context in self.contexts:
+            results.append(f"+{context}")
+        for key, val in self.keyval.items():
+            results.append(f"{key}:{val}")
+        return len(", ".join(results))

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]] = []