zrb 1.0.0a5__py3-none-any.whl → 1.0.0a10__py3-none-any.whl

zrb/task/base_task.py

@@ -38,6 +38,7 @@ class BaseTask(AnyTask):
         monitor_readiness: bool = False,
         upstream: list[AnyTask] | AnyTask | None = None,
         fallback: list[AnyTask] | AnyTask | None = None,
+        successor: list[AnyTask] | AnyTask | None = None,
     ):
         self._name = name
         self._color = color
@@ -50,6 +51,7 @@ class BaseTask(AnyTask):
         self._retry_period = retry_period
         self._upstreams = upstream
         self._fallbacks = fallback
+        self._successors = successor
         self._readiness_checks = readiness_check
         self._readiness_check_delay = readiness_check_delay
         self._readiness_check_period = readiness_check_period
@@ -65,17 +67,17 @@ class BaseTask(AnyTask):
     def __rshift__(self, other: AnyTask | list[AnyTask]) -> AnyTask:
         try:
             if isinstance(other, AnyTask):
-                other.append_upstreams(self)
+                other.append_upstream(self)
             elif isinstance(other, list):
                 for task in other:
-                    task.append_upstreams(self)
+                    task.append_upstream(self)
             return other
         except Exception as e:
             raise ValueError(f"Invalid operation {self} >> {other}: {e}")
 
     def __lshift__(self, other: AnyTask | list[AnyTask]) -> AnyTask:
         try:
-            self.append_upstreams(other)
+            self.append_upstream(other)
             return self
         except Exception as e:
             raise ValueError(f"Invalid operation {self} << {other}: {e}")
@@ -142,6 +144,44 @@ class BaseTask(AnyTask):
             return [self._fallbacks]
         return self._fallbacks
 
+    def append_fallback(self, fallbacks: AnyTask | list[AnyTask]):
+        fallback_list = [fallbacks] if isinstance(fallbacks, AnyTask) else fallbacks
+        for fallback in fallback_list:
+            self.__append_fallback(fallback)
+
+    def __append_fallback(self, fallback: AnyTask):
+        # Make sure self._fallbacks is a list
+        if self._fallbacks is None:
+            self._fallbacks = []
+        elif isinstance(self._fallbacks, AnyTask):
+            self._fallbacks = [self._fallbacks]
+        # Add fallback if it was not on self._fallbacks
+        if fallback not in self._fallbacks:
+            self._fallbacks.append(fallback)
+
+    @property
+    def successors(self) -> list[AnyTask]:
+        if self._successors is None:
+            return []
+        elif isinstance(self._successors, AnyTask):
+            return [self._successors]
+        return self._successors
+
+    def append_successor(self, successors: AnyTask | list[AnyTask]):
+        successor_list = [successors] if isinstance(successors, AnyTask) else successors
+        for successor in successor_list:
+            self.__append_successor(successor)
+
+    def __append_successor(self, successor: AnyTask):
+        # Make sure self._successors is a list
+        if self._successors is None:
+            self._successors = []
+        elif isinstance(self._successors, AnyTask):
+            self._successors = [self._successors]
+        # Add successor if it was not on self._successors
+        if successor not in self._successors:
+            self._successors.append(successor)
+
     @property
     def readiness_checks(self) -> list[AnyTask]:
         if self._readiness_checks is None:
@@ -150,6 +190,25 @@ class BaseTask(AnyTask):
             return [self._readiness_checks]
         return self._readiness_checks
 
+    def append_readiness_check(self, readiness_checks: AnyTask | list[AnyTask]):
+        readiness_check_list = (
+            [readiness_checks]
+            if isinstance(readiness_checks, AnyTask)
+            else readiness_checks
+        )
+        for readiness_check in readiness_check_list:
+            self.__append_readiness_check(readiness_check)
+
+    def __append_readiness_check(self, readiness_check: AnyTask):
+        # Make sure self._readiness_checks is a list
+        if self._readiness_checks is None:
+            self._readiness_checks = []
+        elif isinstance(self._readiness_checks, AnyTask):
+            self._readiness_checks = [self._readiness_checks]
+        # Add readiness_check if it was not on self._readiness_checks
+        if readiness_check not in self._readiness_checks:
+            self._readiness_checks.append(readiness_check)
+
     @property
     def upstreams(self) -> list[AnyTask]:
         if self._upstreams is None:
@@ -158,7 +217,7 @@ class BaseTask(AnyTask):
             return [self._upstreams]
         return self._upstreams
 
-    def append_upstreams(self, upstreams: AnyTask | list[AnyTask]):
+    def append_upstream(self, upstreams: AnyTask | list[AnyTask]):
         upstream_list = [upstreams] if isinstance(upstreams, AnyTask) else upstreams
         for upstream in upstream_list:
             self.__append_upstream(upstream)
@@ -374,6 +433,7 @@ class BaseTask(AnyTask):
                 # Put result on xcom
                 task_xcom: Xcom = ctx.xcom.get(self.name)
                 task_xcom.push(result)
+                await run_async(self.__exec_successors(session))
                 return result
             except (asyncio.CancelledError, KeyboardInterrupt):
                 ctx.log_info("Marked as failed")
@@ -390,6 +450,13 @@ class BaseTask(AnyTask):
                 await run_async(self.__exec_fallbacks(session))
                 raise e
 
+    async def __exec_successors(self, session: AnySession) -> Any:
+        successors: list[AnyTask] = self.successors
+        successor_coros = [
+            run_async(successor.exec_chain(session)) for successor in successors
+        ]
+        await asyncio.gather(*successor_coros)
+
     async def __exec_fallbacks(self, session: AnySession) -> Any:
         fallbacks: list[AnyTask] = self.fallbacks
         fallback_coros = [

zrb/task/cmd_task.py

@@ -5,13 +5,14 @@ import sys
 from zrb.attr.type import BoolAttr, IntAttr, StrAttr
 from zrb.cmd.cmd_result import CmdResult
 from zrb.cmd.cmd_val import AnyCmdVal, CmdVal, SingleCmdVal
-from zrb.config import DEFAULT_SHELL
+from zrb.config import DEFAULT_SHELL, WARN_UNRECOMMENDED_COMMAND
 from zrb.context.any_context import AnyContext
 from zrb.env.any_env import AnyEnv
 from zrb.input.any_input import AnyInput
 from zrb.task.any_task import AnyTask
 from zrb.task.base_task import BaseTask
 from zrb.util.attr import get_int_attr, get_str_attr
+from zrb.util.cmd.command import check_unrecommended_commands
 from zrb.util.cmd.remote import get_remote_cmd_script
 
 
@@ -32,6 +33,7 @@ class CmdTask(BaseTask):
         remote_host: StrAttr | None = None,
         render_remote_host: bool = True,
         remote_port: IntAttr | None = None,
+        render_remote_port: bool = True,
         remote_user: StrAttr | None = None,
         render_remote_user: bool = True,
         remote_password: StrAttr | None = None,
@@ -42,6 +44,7 @@ class CmdTask(BaseTask):
         render_cmd: bool = True,
         cwd: str | None = None,
         render_cwd: bool = True,
+        warn_unrecommended_command: bool | None = None,
         max_output_line: int = 1000,
         max_error_line: int = 1000,
         execute_condition: BoolAttr = True,
@@ -83,6 +86,7 @@ class CmdTask(BaseTask):
         self._remote_host = remote_host
         self._render_remote_host = render_remote_host
         self._remote_port = remote_port
+        self._render_remote_port = render_remote_port
         self._remote_user = remote_user
         self._render_remote_user = render_remote_user
         self._remote_password = remote_password
@@ -95,6 +99,7 @@ class CmdTask(BaseTask):
         self._render_cwd = render_cwd
         self._max_output_line = max_output_line
         self._max_error_line = max_error_line
+        self._should_warn_unrecommended_command = warn_unrecommended_command
 
     async def _exec_action(self, ctx: AnyContext) -> CmdResult:
         """Turn _cmd attribute into subprocess.Popen and execute it as task's action.
@@ -105,7 +110,6 @@ class CmdTask(BaseTask):
         Returns:
             Any: The result of the action execution.
         """
-        ctx.log_info("Running script")
         cmd_script = self._get_cmd_script(ctx)
         ctx.log_debug(f"Script: {self.__get_multiline_repr(cmd_script)}")
         shell = self._get_shell(ctx)
@@ -116,7 +120,10 @@ class CmdTask(BaseTask):
         env_map = self.__get_env_map(ctx)
         ctx.log_debug(f"Environment map: {env_map}")
         cmd_process = None
+        if self._get_should_warn_unrecommended_commands():
+            self._check_unrecommended_commands(ctx, shell, cmd_script)
         try:
+            ctx.log_info("Running script")
             cmd_process = await asyncio.create_subprocess_exec(
                 shell,
                 shell_flag,
@@ -150,6 +157,21 @@ class CmdTask(BaseTask):
             if cmd_process is not None and cmd_process.returncode is None:
                 cmd_process.terminate()
 
+    def _get_should_warn_unrecommended_commands(self):
+        if self._should_warn_unrecommended_command is None:
+            return WARN_UNRECOMMENDED_COMMAND
+        return self._should_warn_unrecommended_command
+
+    def _check_unrecommended_commands(
+        self, ctx: AnyContext, shell: str, cmd_script: str
+    ):
+        if shell.endswith("bash") or shell.endswith("zsh"):
+            unrecommended_commands = check_unrecommended_commands(cmd_script)
+            if unrecommended_commands:
+                ctx.log_warning("The script contains unrecommended commands")
+            for command, reason in unrecommended_commands.items():
+                ctx.log_warning(f"- {command}: {reason}")
+
     def __get_env_map(self, ctx: AnyContext) -> dict[str, str]:
         envs = {key: val for key, val in ctx.env.items()}
         envs["_ZRB_SSH_PASSWORD"] = self._get_remote_password(ctx)
@@ -195,7 +217,9 @@ class CmdTask(BaseTask):
         )
 
     def _get_remote_port(self, ctx: AnyContext) -> int:
-        return get_int_attr(ctx, self._remote_port, 22, auto_render=True)
+        return get_int_attr(
+            ctx, self._remote_port, 22, auto_render=self._render_remote_port
+        )
 
     def _get_remote_user(self, ctx: AnyContext) -> str:
         return get_str_attr(

zrb/task/llm_task.py

@@ -108,8 +108,13 @@ class LLMTask(BaseTask):
         )
 
     async def _exec_action(self, ctx: AnyContext) -> Any:
-        from litellm import acompletion
+        from litellm import acompletion, supports_function_calling
 
+        model = self._get_model(ctx)
+        try:
+            allow_function_call = supports_function_calling(model=model)
+        except Exception:
+            allow_function_call = False
         model_kwargs = self._get_model_kwargs(ctx)
         ctx.log_debug("MODEL KWARGS", model_kwargs)
         system_prompt = self._get_system_prompt(ctx)
@@ -121,27 +126,28 @@ class LLMTask(BaseTask):
         messages = history + [user_message]
         available_tools = self._get_tools(ctx)
         available_tools["scratchpad"] = scratchpad
-        tool_schema = [
-            callable_to_tool_schema(tool, name)
-            for name, tool in available_tools.items()
-        ]
-        for additional_tool in self._additional_tools:
-            fn = additional_tool.fn
-            tool_name = additional_tool.name or fn.__name__
-            tool_description = additional_tool.description
-            available_tools[tool_name] = additional_tool.fn
-            tool_schema.append(
-                callable_to_tool_schema(
-                    fn, name=tool_name, description=tool_description
+        if allow_function_call:
+            tool_schema = [
+                callable_to_tool_schema(tool, name)
+                for name, tool in available_tools.items()
+            ]
+            for additional_tool in self._additional_tools:
+                fn = additional_tool.fn
+                tool_name = additional_tool.name or fn.__name__
+                tool_description = additional_tool.description
+                available_tools[tool_name] = additional_tool.fn
+                tool_schema.append(
+                    callable_to_tool_schema(
+                        fn, name=tool_name, description=tool_description
+                    )
                 )
-            )
-        ctx.log_debug("TOOL SCHEMA", tool_schema)
+            model_kwargs["tools"] = tool_schema
+            ctx.log_debug("TOOL SCHEMA", tool_schema)
         history_file = self._get_history_file(ctx)
         while True:
             response = await acompletion(
-                model=self._get_model(ctx),
+                model=model,
                 messages=[{"role": "system", "content": system_prompt}] + messages,
-                tools=tool_schema,
                 **model_kwargs,
             )
             response_message = response.choices[0].message
@@ -189,7 +195,7 @@ class LLMTask(BaseTask):
     def _get_model_kwargs(self, ctx: AnyContext) -> dict[str, Callable]:
         if callable(self._model_kwargs):
             return self._model_kwargs(ctx)
-        return self._model_kwargs
+        return {**self._model_kwargs}
 
     def _get_tools(self, ctx: AnyContext) -> dict[str, Callable]:
         if callable(self._tools):

zrb/task/rsync_task.py

@@ -24,13 +24,13 @@ class RsyncTask(CmdTask):
         remote_host: StrAttr | None = None,
         auto_render_remote_host: bool = True,
         remote_port: IntAttr | None = None,
-        auto_render_remote_port: bool = True,
+        render_remote_port: bool = True,
         remote_user: StrAttr | None = None,
-        auto_render_remote_user: bool = True,
+        render_remote_user: bool = True,
         remote_password: StrAttr | None = None,
-        auto_render_remote_password: bool = True,
+        render_remote_password: bool = True,
         remote_ssh_key: StrAttr | None = None,
-        auto_render_remote_ssh_key: bool = True,
+        render_remote_ssh_key: bool = True,
         remote_source_path: StrAttr | None = None,
         render_remote_source_path: bool = True,
         remote_destination_path: StrAttr | None = None,
@@ -63,13 +63,13 @@ class RsyncTask(CmdTask):
             remote_host=remote_host,
             render_remote_host=auto_render_remote_host,
             remote_port=remote_port,
-            auto_render_remote_port=auto_render_remote_port,
+            auto_render_remote_port=render_remote_port,
             remote_user=remote_user,
-            render_remote_user=auto_render_remote_user,
+            render_remote_user=render_remote_user,
             remote_password=remote_password,
-            render_remote_password=auto_render_remote_password,
+            render_remote_password=render_remote_password,
             remote_ssh_key=remote_ssh_key,
-            render_remote_ssh_key=auto_render_remote_ssh_key,
+            render_remote_ssh_key=render_remote_ssh_key,
             cwd=cwd,
             render_cwd=auto_render_cwd,
             max_output_line=max_output_line,

zrb/util/cmd/command.py

@@ -0,0 +1,33 @@
+import re
+
+
+def check_unrecommended_commands(cmd_script: str) -> dict[str, str]:
+    banned_commands = {
+        "<(": "Process substitution isn't POSIX compliant and causes trouble",
+        "column": "Command isn't included in Ubuntu packages and is not POSIX compliant",
+        "echo": "echo isn't consistent across OS; use printf instead",
+        "eval": "Avoid eval as it can accidentally execute arbitrary strings",
+        "realpath": "Not available by default on OSX",
+        "source": "Not POSIX compliant; use '.' instead",
+        " test": "Use '[' instead for consistency",
+        "which": "Command in not POSIX compliant, use command -v",
+    }
+    banned_commands_regex = {
+        r"grep.* -y": "grep -y does not work on Alpine; use grep -i",
+        r"grep.* -P": "grep -P is not valid on OSX",
+        r"grep[^|]+--\w{2,}": "grep long commands do not work on Alpine",
+        r'readlink.+-.*f.+["$]': "readlink -f behaves differently on OSX",
+        r"sort.*-V": "sort -V is not supported everywhere",
+        r"sort.*--sort-versions": "sort --sort-version is not supported everywhere",
+        r"\bls ": "Avoid using ls; use shell globs or find instead",
+    }
+    violations = {}
+    # Check banned commands
+    for cmd, reason in banned_commands.items():
+        if cmd in cmd_script:
+            violations[cmd] = reason
+    # Check banned regex patterns
+    for pattern, reason in banned_commands_regex.items():
+        if re.search(pattern, cmd_script):
+            violations[pattern] = reason
+    return violations

zrb/util/codemod/add_parent_to_class.py

@@ -0,0 +1,38 @@
+import libcst as cst
+
+
+class ParentClassAdder(cst.CSTTransformer):
+    def __init__(self, class_name: str, parent_class_name: str):
+        self.class_name = class_name
+        self.parent_class_name = parent_class_name
+        self.class_found = False
+
+    def leave_ClassDef(
+        self, original_node: cst.ClassDef, updated_node: cst.ClassDef
+    ) -> cst.ClassDef:
+        # Check if this is the target class
+        if original_node.name.value == self.class_name:
+            self.class_found = True
+            # Add the parent class to the existing bases
+            new_bases = (
+                cst.Arg(value=cst.Name(self.parent_class_name)),
+                *updated_node.bases,
+            )
+            return updated_node.with_changes(bases=new_bases)
+        return updated_node
+
+
+def add_parent_to_class(
+    original_code: str, class_name: str, parent_class_name: str
+) -> str:
+    # Parse the original code into a module
+    module = cst.parse_module(original_code)
+    # Initialize transformer with the class name and parent class name
+    transformer = ParentClassAdder(class_name, parent_class_name)
+    # Apply the transformation
+    modified_module = module.visit(transformer)
+    # Check if the class was found
+    if not transformer.class_found:
+        raise ValueError(f"Class {class_name} not found in the provided code.")
+    # Return the modified code
+    return modified_module.code

zrb/util/git.py

@@ -1,3 +1,4 @@
+import os
 import subprocess
 
 from pydantic import BaseModel
@@ -9,14 +10,19 @@ class DiffResult(BaseModel):
     updated: list[str]
 
 
-def get_diff(source_commit: str, current_commit: str) -> DiffResult:
-    # git show b176b5a main
-    exit_status, output = subprocess.getstatusoutput(
-        f"git diff {source_commit} {current_commit}"
-    )
-    if exit_status != 0:
-        raise Exception(output)
-    lines = output.split("\n")
+def get_diff(repo_dir: str, source_commit: str, current_commit: str) -> DiffResult:
+    try:
+        result = subprocess.run(
+            ["git", "diff", source_commit, current_commit],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            cwd=repo_dir,
+            text=True,
+            check=True,
+        )
+    except subprocess.CalledProcessError as e:
+        raise Exception(e.stderr or e.stdout)
+    lines = result.stdout.strip().split("\n")
     diff: dict[str, dict[str, bool]] = {}
     for line in lines:
         if not line.startswith("---") and not line.startswith("+++"):
@@ -55,17 +61,18 @@ def get_repo_dir() -> str:
             check=True,
         )
         # Return the directory path
-        return result.stdout.strip()
+        return os.path.abspath(result.stdout.strip())
     except subprocess.CalledProcessError as e:
         raise Exception(e.stderr or e.stdout)
 
 
-def get_current_branch() -> str:
+def get_current_branch(repo_dir: str) -> str:
     try:
         result = subprocess.run(
             ["git", "rev-parse", "--abbrev-ref", "HEAD"],
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
+            cwd=repo_dir,
             text=True,
             check=True,
         )
@@ -74,12 +81,13 @@ def get_current_branch() -> str:
         raise Exception(e.stderr or e.stdout)
 
 
-def get_branches() -> list[str]:
+def get_branches(repo_dir: str) -> list[str]:
     try:
         result = subprocess.run(
             ["git", "branch"],
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
+            cwd=repo_dir,
             text=True,
             check=True,
         )
@@ -90,12 +98,13 @@ def get_branches() -> list[str]:
         raise Exception(e.stderr or e.stdout)
 
 
-def delete_branch(branch_name: str) -> str:
+def delete_branch(repo_dir: str, branch_name: str) -> str:
     try:
         result = subprocess.run(
             ["git", "branch", "-D", branch_name],
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
+            cwd=repo_dir,
             text=True,
             check=True,
         )
@@ -104,12 +113,13 @@ def delete_branch(branch_name: str) -> str:
         raise Exception(e.stderr or e.stdout)
 
 
-def add() -> str:
+def add(repo_dir: str) -> str:
     try:
         subprocess.run(
             ["git", "add", ".", "-A"],
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
+            cwd=repo_dir,
             text=True,
             check=True,
         )
@@ -117,25 +127,32 @@ def add() -> str:
         raise Exception(e.stderr or e.stdout)
 
 
-def commit(message: str) -> str:
+def commit(repo_dir: str, message: str) -> str:
     try:
         subprocess.run(
             ["git", "commit", "-m", message],
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
+            cwd=repo_dir,
             text=True,
             check=True,
         )
     except subprocess.CalledProcessError as e:
-        raise Exception(e.stderr or e.stdout)
+        ignored_error_message = "nothing to commit, working tree clean"
+        if (
+            ignored_error_message not in e.stderr
+            and ignored_error_message not in e.stdout
+        ):
+            raise Exception(e.stderr or e.stdout)
 
 
-def pull(remote: str, branch: str) -> str:
+def pull(repo_dir: str, remote: str, branch: str) -> str:
     try:
         subprocess.run(
             ["git", "pull", remote, branch],
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
+            cwd=repo_dir,
             text=True,
             check=True,
         )
@@ -143,12 +160,13 @@ def pull(remote: str, branch: str) -> str:
         raise Exception(e.stderr or e.stdout)
 
 
-def push(remote: str, branch: str) -> str:
+def push(repo_dir: str, remote: str, branch: str) -> str:
     try:
         subprocess.run(
             ["git", "push", "-u", remote, branch],
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
+            cwd=repo_dir,
             text=True,
             check=True,
         )

zrb/util/git_subtree.py

@@ -3,8 +3,6 @@ import subprocess
 
 from pydantic import BaseModel
 
-from zrb.util.git import get_repo_dir
-
 
 class SingleSubTreeConfig(BaseModel):
     repo_url: str
@@ -16,21 +14,21 @@ class SubTreeConfig(BaseModel):
     data: dict[str, SingleSubTreeConfig]
 
 
-def load_config() -> SubTreeConfig:
-    file_path = os.path.join(get_repo_dir(), "subtrees.json")
+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())
 
 
-def save_config(config: SubTreeConfig):
-    file_path = os.path.join(get_repo_dir(), "subtrees.json")
+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))
 
 
-def add_subtree(name: str, repo_url: str, branch: str, prefix: str):
+def add_subtree(repo_dir: str, name: str, repo_url: str, branch: str, prefix: str):
     config = load_config()
     if os.path.isdir(prefix):
         raise ValueError(f"Directory exists: {prefix}")
@@ -41,6 +39,7 @@ def add_subtree(name: str, repo_url: str, branch: str, prefix: str):
             ["git", "subtree", "add", "--prefix", prefix, repo_url, branch],
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
+            cwd=repo_dir,
             text=True,
             check=True,
         )
@@ -49,10 +48,10 @@ def add_subtree(name: str, repo_url: str, branch: str, prefix: str):
     config.data[name] = SingleSubTreeConfig(
         repo_url=repo_url, branch=branch, prefix=prefix
     )
-    save_config(config)
+    save_config(repo_dir, config)
 
 
-def pull_subtree(prefix: str, repo_url: str, branch: str):
+def pull_subtree(repo_dir: str, prefix: str, repo_url: str, branch: str):
     try:
         subprocess.run(
             [
@@ -66,6 +65,7 @@ def pull_subtree(prefix: str, repo_url: str, branch: str):
             ],
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
+            cwd=repo_dir,
             text=True,
             check=True,
         )
@@ -73,7 +73,7 @@ def pull_subtree(prefix: str, repo_url: str, branch: str):
         raise Exception(e.stderr or e.stdout)
 
 
-def push_subtree(prefix: str, repo_url: str, branch: str):
+def push_subtree(repo_dir: str, prefix: str, repo_url: str, branch: str):
     try:
         subprocess.run(
             [
@@ -87,6 +87,7 @@ def push_subtree(prefix: str, repo_url: str, branch: str):
             ],
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
+            cwd=repo_dir,
             text=True,
             check=True,
         )

zrb/util/string/format.py

@@ -1,9 +1,19 @@
+import re
 from typing import Any
 
 
 def fstring_format(template: str, data: dict[str, Any]) -> str:
-    # Safely evaluate the template as a Python expression
+    def replace_expr(match):
+        expr = match.group(1)
+        try:
+            result = eval(expr, {}, data)
+            return str(result)
+        except Exception as e:
+            raise ValueError(f"Failed to evaluate expression: {expr}: {e}")
+
+    # Use regex to find and replace all expressions in curly braces
+    pattern = r"\{([^}]+)\}"
     try:
-        return eval(f'f"""{template}"""', {}, data)
+        return re.sub(pattern, replace_expr, template)
     except Exception as e:
         raise ValueError(f"Failed to parse template: {template}: {e}")

{zrb-1.0.0a5.dist-info → zrb-1.0.0a10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zrb
-Version: 1.0.0a5
+Version: 1.0.0a10
 Summary: Your Automation Powerhouse
 Home-page: https://github.com/state-alchemists/zrb
 License: AGPL-3.0-or-later
@@ -13,6 +13,7 @@ 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
 Provides-Extra: rag
 Requires-Dist: autopep8 (>=2.0.4,<3.0.0)
 Requires-Dist: beautifulsoup4 (>=4.12.3,<5.0.0)