zrb 1.0.0a15__py3-none-any.whl → 1.0.0a18__py3-none-any.whl

zrb/task/scaffolder.py

@@ -30,9 +30,11 @@ class Scaffolder(BaseTask):
         destination_path: StrAttr | None = None,
         render_destination_path: bool = True,
         transform_path: TransformConfig = {},
+        render_transform_path: bool = True,
         transform_content: (
             list[AnyContentTransformer] | AnyContentTransformer | TransformConfig
         ) = [],
+        render_transform_content: bool = True,
         execute_condition: BoolAttr = True,
         retries: int = 2,
         retry_period: float = 0,
@@ -70,7 +72,9 @@ class Scaffolder(BaseTask):
         self._destination_path = destination_path
         self._render_destination_path = render_destination_path
         self._content_transformers = transform_content
+        self._render_content_transformers = render_transform_content
         self._path_transformer = transform_path
+        self._render_path_transformer = render_transform_path
 
     def _get_source_path(self, ctx: AnyContext) -> str:
         return get_str_attr(ctx, self._source_path, "", auto_render=True)
@@ -80,9 +84,17 @@ class Scaffolder(BaseTask):
 
     def _get_content_transformers(self) -> list[AnyContentTransformer]:
         if callable(self._content_transformers):
-            return [ContentTransformer(match="*", transform=self._content_transformers)]
+            return [
+                ContentTransformer(match=".*", transform=self._content_transformers)
+            ]
         if isinstance(self._content_transformers, dict):
-            return [ContentTransformer(match="*", transform=self._content_transformers)]
+            return [
+                ContentTransformer(
+                    match=".*",
+                    transform=self._content_transformers,
+                    auto_render=self._render_content_transformers,
+                )
+            ]
         if isinstance(self._content_transformers, AnyContentTransformer):
             return [self._content_transformers]
         return self._content_transformers
@@ -117,17 +129,19 @@ class Scaffolder(BaseTask):
                     dest_file = os.path.join(
                         dest_dir, self._transform_path(ctx, file_name)
                     )
+                    ctx.log_info(f"Copying {src_file} to {dest_file}")
                     shutil.copy2(src_file, dest_file)
-                    ctx.log_info(f"Copied {src_file} to {dest_file}")
         else:
+            ctx.log_info(f"Copying {source_path} to {destination_path}")
             shutil.copy2(source_path, destination_path)
-            ctx.log_info(f"Copied {source_path} to {destination_path}")
 
     def _transform_path(self, ctx: AnyContext, file_path: str):
         if callable(self._path_transformer):
             return self._path_transformer(ctx, file_path)
         new_file_path = file_path
         for keyword, replacement in self._path_transformer.items():
+            if self._render_path_transformer:
+                replacement = ctx.render(replacement)
             new_file_path = new_file_path.replace(keyword, replacement)
         return new_file_path
 

zrb/task/scheduler.py

@@ -16,7 +16,6 @@ from zrb.xcom.xcom import Xcom
 
 
 class Scheduler(BaseTrigger):
-
     def __init__(
         self,
         name: str,

zrb/util/cmd/command.py

@@ -47,7 +47,6 @@ async def run_command(
     max_output_line: int = 1000,
     max_error_line: int = 1000,
 ) -> tuple[CmdResult, int]:
-
     async def __read_stream(
         stream, log_method: Callable[..., None], max_lines: int
     ) -> str:

zrb/util/codemod/{add_code_to_class.py → append_code_to_class.py}

@@ -4,7 +4,7 @@ import libcst as cst
 class ClassCodeAdder(cst.CSTTransformer):
     def __init__(self, class_name: str, new_code: str):
         self.class_name = class_name
-        self.new_code = cst.parse_statement(new_code)
+        self.new_code = cst.parse_module(new_code).body
         self.class_found = False
 
     def leave_ClassDef(
@@ -15,17 +15,17 @@ class ClassCodeAdder(cst.CSTTransformer):
             self.class_found = True
             # Add the method to the class body
             new_body = updated_node.body.with_changes(
-                body=updated_node.body.body + (self.new_code,)
+                body=updated_node.body.body + tuple(self.new_code)
             )
             return updated_node.with_changes(body=new_body)
         return updated_node
 
 
-def add_code_to_class(original_code: str, class_name: str, method_code: str) -> str:
+def append_code_to_class(original_code: str, class_name: str, new_code: str) -> str:
     # Parse the original code into a module
     module = cst.parse_module(original_code)
     # Initialize transformer with the class name and method code
-    transformer = ClassCodeAdder(class_name, method_code)
+    transformer = ClassCodeAdder(class_name, new_code)
     # Apply the transformation
     modified_module = module.visit(transformer)
     # Check if the class was found

zrb/util/codemod/{add_code_to_function.py → append_code_to_function.py}

@@ -5,7 +5,7 @@ class FunctionCodeAdder(cst.CSTTransformer):
     def __init__(self, function_name: str, new_code: str):
         self.function_name = function_name
         # Use parse_module to handle multiple statements
-        self.new_code = cst.parse_statement(new_code)
+        self.new_code = cst.parse_module(new_code).body
         self.function_found = False
 
     def leave_FunctionDef(
@@ -16,13 +16,15 @@ class FunctionCodeAdder(cst.CSTTransformer):
             self.function_found = True
             # Add the method to the class body
             new_body = updated_node.body.with_changes(
-                body=updated_node.body.body + (self.new_code,)
+                body=updated_node.body.body + tuple(self.new_code)
             )
             return updated_node.with_changes(body=new_body)
         return updated_node
 
 
-def add_code_to_function(original_code: str, function_name: str, new_code: str) -> str:
+def append_code_to_function(
+    original_code: str, function_name: str, new_code: str
+) -> str:
     # Parse the original code into a module
     module = cst.parse_module(original_code)
     # Initialize the transformer with the necessary information

zrb/util/codemod/{add_code_to_method.py → append_code_to_method.py}

@@ -6,7 +6,7 @@ class MethodCodeAdder(cst.CSTTransformer):
         self.class_name = class_name
         self.method_name = method_name
         # Use parse_module to handle multiple statements
-        self.new_code = cst.parse_statement(new_code)
+        self.new_code = cst.parse_module(new_code).body
         self.class_found = False
         self.method_found = False
 
@@ -27,7 +27,7 @@ class MethodCodeAdder(cst.CSTTransformer):
                 ):
                     # Modify the target function by adding the new code
                     body_with_new_code = item.body.with_changes(
-                        body=item.body.body + (self.new_code,)  # Add the new code
+                        body=item.body.body + tuple(self.new_code)  # Add the new code
                     )
                     new_body.append(item.with_changes(body=body_with_new_code))
                     self.method_found = True
@@ -37,7 +37,7 @@ class MethodCodeAdder(cst.CSTTransformer):
         return updated_node
 
 
-def add_code_to_method(
+def append_code_to_method(
     original_code: str, class_name: str, function_name: str, new_code: str
 ) -> str:
     # Parse the original code into a module

zrb/util/codemod/{add_key_to_dict.py → append_key_to_dict.py}

@@ -33,7 +33,7 @@ class DictionaryModifier(cst.CSTTransformer):
         return updated_node
 
 
-def add_key_to_dict(
+def append_key_to_dict(
     original_code: str, dictionary_name: str, new_key: str, new_value: str
 ) -> str:
     # Parse the original code into a module

zrb/util/codemod/{add_param_to_function_call.py → append_param_to_function_call.py}

@@ -21,7 +21,7 @@ class FunctionCallParamAdder(cst.CSTTransformer):
         return updated_node
 
 
-def add_param_to_function_call(
+def append_param_to_function_call(
     original_code: str, func_name: str, new_param: str
 ) -> str:
     # Parse the original code into a module

zrb/util/codemod/{add_code_to_module.py → prepend_code_to_module.py}

@@ -1,5 +1,5 @@
-def add_code_to_module(source_code: str, new_code: str) -> str:
-    lines = source_code.splitlines()
+def prepend_code_to_module(original_code: str, new_code: str) -> str:
+    lines = original_code.splitlines()
     last_import_index = -1
     for i, line in enumerate(lines):
         stripped_line = line.strip()

zrb/util/codemod/{add_parent_to_class.py → prepend_parent_to_class.py}

@@ -22,7 +22,7 @@ class ParentClassAdder(cst.CSTTransformer):
         return updated_node
 
 
-def add_parent_to_class(
+def prepend_parent_class(
     original_code: str, class_name: str, parent_class_name: str
 ) -> str:
     # Parse the original code into a module

zrb/util/codemod/{add_property_to_class.py → prepend_property_to_class.py}

@@ -33,7 +33,7 @@ class ClassPropertyAdder(cst.CSTTransformer):
         return updated_node
 
 
-def add_property_to_class(
+def prepend_property_to_class(
     original_code: str,
     class_name: str,
     property_name: str,

zrb/util/file.py

@@ -0,0 +1,18 @@
+import os
+
+
+def read_file(file_path: str, replace_map: dict[str, str] = {}) -> str:
+    with open(file_path, "r", encoding="utf-8") as f:
+        content = f.read()
+    for key, val in replace_map.items():
+        content = content.replace(key, val)
+    return content
+
+
+def write_file(file_path: str, content: str | list[str]):
+    if isinstance(content, list):
+        content = "\n".join([line for line in content if line is not None])
+    dir_path = os.path.dirname(file_path)
+    os.makedirs(dir_path, exist_ok=True)
+    with open(file_path, "w") as f:
+        f.write(content.strip())

zrb/util/git_subtree.py

@@ -5,6 +5,7 @@ from typing import Any
 from pydantic import BaseModel
 
 from zrb.util.cmd.command import run_command
+from zrb.util.file import read_file, write_file
 
 
 class SingleSubTreeConfig(BaseModel):
@@ -21,14 +22,12 @@ def load_config(repo_dir: str) -> SubTreeConfig:
     file_path = os.path.join(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())
+    return SubTreeConfig.model_validate_json(read_file(file_path))
 
 
 def save_config(repo_dir: str, config: SubTreeConfig):
     file_path = os.path.join(repo_dir, "subtrees.json")
-    with open(file_path, "w") as f:
-        f.write(config.model_dump_json(indent=2))
+    write_file(file_path, config.model_dump_json(indent=2))
 
 
 async def add_subtree(

zrb/util/todo.py

@@ -1,20 +1,27 @@
 import datetime
 import re
 import shutil
-from typing import Any
 
 from pydantic import BaseModel, Field, model_validator
 
 from zrb.util.cli.style import (
-    stylize_bold_green,
     stylize_bold_yellow,
     stylize_cyan,
     stylize_faint,
     stylize_magenta,
     stylize_yellow,
 )
+from zrb.util.file import read_file, write_file
 from zrb.util.string.name import get_random_name
 
+_DATE_TIME_STR_WIDTH = 14
+_MAX_DESCRIPTION_WIDTH = 70
+_PRIORITY_WIDTH = 3
+_COMPLETED_WIDTH = 3
+_COMPLETED_AT_WIDTH = _DATE_TIME_STR_WIDTH
+_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, ...
@@ -87,8 +94,7 @@ def select_todo_task(
 
 
 def load_todo_list(todo_file_path: str) -> list[TodoTaskModel]:
-    with open(todo_file_path, "r") as f:
-        todo_lines = f.read().strip().split("\n")
+    todo_lines = read_file(todo_file_path).strip().split("\n")
     todo_list: list[TodoTaskModel] = []
     for todo_line in todo_lines:
         todo_line = todo_line.strip()
@@ -108,9 +114,9 @@ def load_todo_list(todo_file_path: str) -> list[TodoTaskModel]:
 
 
 def save_todo_list(todo_file_path: str, todo_list: list[TodoTaskModel]):
-    with open(todo_file_path, "w") as f:
-        for todo_task in todo_list:
-            f.write(todo_task_to_line(todo_task) + "\n")
+    write_file(
+        todo_file_path, [todo_task_to_line(todo_task) for todo_task in todo_list]
+    )
 
 
 def line_to_todo_task(line: str) -> TodoTaskModel:
@@ -215,8 +221,8 @@ def get_visual_todo_list(todo_list: list[TodoTaskModel], filter: str) -> str:
     )
     if max_desc_length < len("DESCRIPTION"):
         max_desc_length = len("DESCRIPTION")
-    if max_desc_length > 70:
-        max_desc_length = 70
+    if max_desc_length > _MAX_DESCRIPTION_WIDTH:
+        max_desc_length = _MAX_DESCRIPTION_WIDTH
     max_additional_info_length = max(
         todo_task.get_additional_info_length() for todo_task in filtered_todo_list
     )
@@ -243,18 +249,24 @@ def get_visual_todo_list(todo_list: list[TodoTaskModel], filter: str) -> str:
 def get_visual_todo_header(
     terminal_width: int, max_desc_length: int, max_additional_info_length: int
 ) -> str:
-    priority = "".ljust(3)
-    completed = "".ljust(3)
-    completed_at = "COMPLETED AT".rjust(14)
-    created_at = "CREATED_AT".ljust(14)
-    description = "DESCRIPTION".ljust(min(max_desc_length, 70))
-    additional_info = "PROJECT/CONTEXT/OTHERS"
-    if terminal_width <= 14 + max_desc_length + max_additional_info_length:
-        return "  ".join([priority, completed, description])
-    if terminal_width <= 36 + max_desc_length + max_additional_info_length:
-        return "  ".join([priority, completed, description, additional_info])
-    return "  ".join(
-        [priority, completed, completed_at, created_at, description, additional_info]
+    priority_caption = "".ljust(_PRIORITY_WIDTH)
+    completed_caption = "".ljust(_COMPLETED_WIDTH)
+    completed_at_caption = "COMPLETED AT".rjust(_COMPLETED_AT_WIDTH)
+    created_at_caption = "CREATED_AT".ljust(_CREATED_AT_WIDTH)
+    description_caption = "DESCRIPTION".ljust(
+        min(max_desc_length, _MAX_DESCRIPTION_WIDTH)
+    )
+    additional_info_caption = "PROJECT/CONTEXT/OTHERS".ljust(max_additional_info_length)
+    return _get_line_str(
+        terminal_width=terminal_width,
+        description_width=min(max_desc_length, _MAX_DESCRIPTION_WIDTH),
+        additional_info_width=max_additional_info_length,
+        priority=priority_caption,
+        completed=completed_caption,
+        completed_at=completed_at_caption,
+        created_at=created_at_caption,
+        description=description_caption,
+        additional_info=additional_info_caption,
     )
 
 
@@ -282,6 +294,17 @@ def get_visual_todo_line(
         + [stylize_cyan(f"@{context}") for context in todo_task.contexts]
         + [stylize_magenta(f"{key}:{val}") for key, val in todo_task.keyval.items()]
     )
+    return _get_line_str(
+        terminal_width=terminal_width,
+        description_width=min(max_desc_length, _MAX_DESCRIPTION_WIDTH),
+        additional_info_width=max_additional_info_length,
+        priority=priority,
+        completed=completed,
+        completed_at=completed_at,
+        created_at=created_at,
+        description=description,
+        additional_info=additional_info,
+    )
     if terminal_width <= 14 + max_desc_length + max_additional_info_length:
         return "  ".join([priority, completed, description])
     if terminal_width <= 36 + max_desc_length + max_additional_info_length:
@@ -291,6 +314,64 @@ def get_visual_todo_line(
     )
 
 
+def _get_line_str(
+    terminal_width: int,
+    description_width: int,
+    additional_info_width: int,
+    priority: str,
+    completed: str,
+    completed_at: str,
+    created_at: str,
+    description: str,
+    additional_info: str,
+):
+    gap = "".ljust(_GAP_WIDTH)
+    if terminal_width >= _get_minimum_width(
+        [
+            _PRIORITY_WIDTH,
+            _COMPLETED_WIDTH,
+            _COMPLETED_AT_WIDTH,
+            _CREATED_AT_WIDTH,
+            description_width,
+            additional_info_width,
+        ]
+    ):
+        return gap.join(
+            [
+                priority,
+                completed,
+                completed_at,
+                created_at,
+                description,
+                additional_info,
+            ]
+        )
+    if terminal_width >= _get_minimum_width(
+        [_PRIORITY_WIDTH, _COMPLETED_WIDTH, description_width, additional_info_width]
+    ):
+        return gap.join([priority, completed, description, additional_info])
+    if terminal_width >= _get_minimum_width(
+        [
+            _PRIORITY_WIDTH,
+            _COMPLETED_WIDTH,
+            _COMPLETED_AT_WIDTH,
+            _CREATED_AT_WIDTH,
+            description_width,
+        ]
+    ):
+        return gap.join([priority, completed, completed_at, created_at, description])
+    if terminal_width >= _get_minimum_width(
+        [_PRIORITY_WIDTH, _COMPLETED_WIDTH, description_width]
+    ):
+        return gap.join([priority, completed, description])
+    return gap.join([priority, description])
+
+
+def _get_minimum_width(field_widths: list[int]) -> int:
+    gap_width = _GAP_WIDTH * (len(field_widths) - 1)
+    return sum(field_width for field_width in field_widths) + gap_width
+
+
 def get_visual_todo_card(
     todo_task: TodoTaskModel, log_work_list: list[dict[str, str]]
 ) -> str:
@@ -344,13 +425,13 @@ def _date_to_str(date: datetime.date | None) -> str:
     return date.strftime("%a %Y-%m-%d")
 
 
-def add_durations(duration1: str, duration2: str) -> str:
-    total_seconds = _parse_duration(duration1) + _parse_duration(duration2)
+def add_duration(duration1: str, duration2: str) -> str:
+    total_seconds = parse_duration(duration1) + parse_duration(duration2)
     # Format and return the result
     return _format_duration(total_seconds)
 
 
-def _parse_duration(duration: str) -> int:
+def parse_duration(duration: str) -> int:
     """Parse a duration string into total seconds."""
     units = {"M": 2592000, "w": 604800, "d": 86400, "h": 3600, "m": 60, "s": 1}
     total_seconds = 0

zrb/xcom/xcom.py

@@ -4,7 +4,6 @@ from typing import Any
 
 
 class Xcom(deque):
-
     def __repr__(self):
         class_name = self.__class__.__name__
         return f"<{class_name} {list(self)}>"

{zrb-1.0.0a15.dist-info → zrb-1.0.0a18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zrb
-Version: 1.0.0a15
+Version: 1.0.0a18
 Summary: Your Automation Powerhouse
 Home-page: https://github.com/state-alchemists/zrb
 License: AGPL-3.0-or-later
@@ -18,7 +18,7 @@ Requires-Dist: autopep8 (>=2.0.4,<3.0.0)
 Requires-Dist: beautifulsoup4 (>=4.12.3,<5.0.0)
 Requires-Dist: black (>=24.10.0,<24.11.0)
 Requires-Dist: chromadb (>=0.5.20,<0.6.0) ; extra == "rag"
-Requires-Dist: fastapi[standard] (>=0.115.5,<0.116.0)
+Requires-Dist: fastapi[standard] (>=0.115.6,<0.116.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)