zrb 1.0.0a2__py3-none-any.whl → 1.0.0a4__py3-none-any.whl

zrb/task/cmd_task.py

@@ -2,17 +2,17 @@ import asyncio
 import os
 import sys
 
-from ..attr.type import BoolAttr, IntAttr, StrAttr
-from ..cmd.cmd_result import CmdResult
-from ..cmd.cmd_val import AnyCmdVal, CmdVal, SingleCmdVal
-from ..config import DEFAULT_SHELL
-from ..context.any_context import AnyContext
-from ..env.any_env import AnyEnv
-from ..input.any_input import AnyInput
-from ..util.attr import get_int_attr, get_str_attr
-from ..util.cmd.remote import get_remote_cmd_script
-from .any_task import AnyTask
-from .base_task import BaseTask
+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.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.remote import get_remote_cmd_script
 
 
 class CmdTask(BaseTask):
@@ -23,25 +23,25 @@ class CmdTask(BaseTask):
         icon: str | None = None,
         description: str | None = None,
         cli_only: bool = False,
-        input: list[AnyInput] | AnyInput | None = None,
-        env: list[AnyEnv] | AnyEnv | None = None,
+        input: list[AnyInput | None] | AnyInput | None = None,
+        env: list[AnyEnv | None] | AnyEnv | None = None,
         shell: StrAttr | None = None,
-        auto_render_shell: bool = True,
+        render_shell: bool = True,
         shell_flag: StrAttr | None = None,
-        auto_render_shell_flag: bool = True,
+        render_shell_flag: bool = True,
         remote_host: StrAttr | None = None,
-        auto_render_remote_host: bool = True,
+        render_remote_host: bool = True,
         remote_port: IntAttr | None = None,
         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,
         cmd: CmdVal = "",
-        auto_render_cmd: bool = True,
+        render_cmd: bool = True,
         cwd: str | None = None,
-        auto_render_cwd: bool = True,
+        render_cwd: bool = True,
         max_output_line: int = 1000,
         max_error_line: int = 1000,
         execute_condition: BoolAttr = True,
@@ -77,22 +77,22 @@ class CmdTask(BaseTask):
             fallback=fallback,
         )
         self._shell = shell
-        self._auto_render_shell = auto_render_shell
+        self._render_shell = render_shell
         self._shell_flag = shell_flag
-        self._auto_render_shell_flag = auto_render_shell_flag
+        self._render_shell_flag = render_shell_flag
         self._remote_host = remote_host
-        self._auto_render_remote_host = auto_render_remote_host
+        self._render_remote_host = render_remote_host
         self._remote_port = remote_port
         self._remote_user = remote_user
-        self._auto_render_remote_user = auto_render_remote_user
+        self._render_remote_user = render_remote_user
         self._remote_password = remote_password
-        self._auto_render_remote_password = auto_render_remote_password
+        self._render_remote_password = render_remote_password
         self._remote_ssh_key = remote_ssh_key
-        self._auto_render_remote_ssh_key = auto_render_remote_ssh_key
+        self._render_remote_ssh_key = render_remote_ssh_key
         self._cmd = cmd
-        self._auto_render_cmd = auto_render_cmd
+        self._render_cmd = render_cmd
         self._cwd = cwd
-        self._auto_render_cwd = auto_render_cwd
+        self._render_cwd = render_cwd
         self._max_output_line = max_output_line
         self._max_error_line = max_error_line
 
@@ -115,36 +115,45 @@ class CmdTask(BaseTask):
         ctx.log_debug(f"Working directory: {cwd}")
         env_map = self.__get_env_map(ctx)
         ctx.log_debug(f"Environment map: {env_map}")
-        cmd_process = await asyncio.create_subprocess_exec(
-            shell,
-            shell_flag,
-            cmd_script,
-            cwd=cwd,
-            stdin=sys.stdin if sys.stdin.isatty() else None,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
-            env=env_map,
-            bufsize=0,
-        )
-        stdout_task = asyncio.create_task(
-            self.__read_stream(cmd_process.stdout, ctx.print, self._max_output_line)
-        )
-        stderr_task = asyncio.create_task(
-            self.__read_stream(cmd_process.stderr, ctx.print, self._max_error_line)
-        )
-        # Wait for process to complete and gather stdout/stderr
-        return_code = await cmd_process.wait()
-        stdout = await stdout_task
-        stderr = await stderr_task
-        # Check for errors
-        if return_code != 0:
-            ctx.log_error(f"Exit status: {return_code}")
-            raise Exception(f"Process {self._name} exited ({return_code}): {stderr}")
-        return CmdResult(stdout, stderr)
+        cmd_process = None
+        try:
+            cmd_process = await asyncio.create_subprocess_exec(
+                shell,
+                shell_flag,
+                cmd_script,
+                cwd=cwd,
+                stdin=sys.stdin if sys.stdin.isatty() else None,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                env=env_map,
+                bufsize=0,
+            )
+            stdout_task = asyncio.create_task(
+                self.__read_stream(cmd_process.stdout, ctx.print, self._max_output_line)
+            )
+            stderr_task = asyncio.create_task(
+                self.__read_stream(cmd_process.stderr, ctx.print, self._max_error_line)
+            )
+            # Wait for process to complete and gather stdout/stderr
+            return_code = await cmd_process.wait()
+            stdout = await stdout_task
+            stderr = await stderr_task
+            # Check for errors
+            if return_code != 0:
+                ctx.log_error(f"Exit status: {return_code}")
+                raise Exception(
+                    f"Process {self._name} exited ({return_code}): {stderr}"
+                )
+            ctx.log_info(f"Exit status: {return_code}")
+            return CmdResult(stdout, stderr)
+        finally:
+            if cmd_process is not None and cmd_process.returncode is None:
+                cmd_process.terminate()
 
     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)
+        envs["PYTHONBUFFERED"] = "1"
         return envs
 
     async def __read_stream(self, stream, log_method, max_lines):
@@ -162,7 +171,7 @@ class CmdTask(BaseTask):
 
     def _get_shell(self, ctx: AnyContext) -> str:
         return get_str_attr(
-            ctx, self._shell, DEFAULT_SHELL, auto_render=self._auto_render_shell
+            ctx, self._shell, DEFAULT_SHELL, auto_render=self._render_shell
         )
 
     def _get_shell_flag(self, ctx: AnyContext) -> str:
@@ -177,12 +186,12 @@ class CmdTask(BaseTask):
             ctx,
             self._shell_flag,
             default_shell_flag,
-            auto_render=self._auto_render_shell_flag,
+            auto_render=self._render_shell_flag,
         )
 
     def _get_remote_host(self, ctx: AnyContext) -> str:
         return get_str_attr(
-            ctx, self._remote_host, "", auto_render=self._auto_render_remote_host
+            ctx, self._remote_host, "", auto_render=self._render_remote_host
         )
 
     def _get_remote_port(self, ctx: AnyContext) -> int:
@@ -190,7 +199,7 @@ class CmdTask(BaseTask):
 
     def _get_remote_user(self, ctx: AnyContext) -> str:
         return get_str_attr(
-            ctx, self._remote_user, "", auto_render=self._auto_render_remote_user
+            ctx, self._remote_user, "", auto_render=self._render_remote_user
         )
 
     def _get_remote_password(self, ctx: AnyContext) -> str:
@@ -198,18 +207,16 @@ class CmdTask(BaseTask):
             ctx,
             self._remote_password,
             "",
-            auto_render=self._auto_render_remote_password,
+            auto_render=self._render_remote_password,
         )
 
     def _get_remote_ssh_key(self, ctx: AnyContext) -> str:
         return get_str_attr(
-            ctx, self._remote_ssh_key, "", auto_render=self._auto_render_remote_ssh_key
+            ctx, self._remote_ssh_key, "", auto_render=self._render_remote_ssh_key
         )
 
     def _get_cwd(self, ctx: AnyContext) -> str:
-        cwd = get_str_attr(
-            ctx, self._cwd, os.getcwd(), auto_render=self._auto_render_cwd
-        )
+        cwd = get_str_attr(ctx, self._cwd, os.getcwd(), auto_render=self._render_cwd)
         if cwd is None:
             cwd = os.getcwd()
         return os.path.abspath(cwd)
@@ -249,7 +256,7 @@ class CmdTask(BaseTask):
         if callable(single_cmd_val):
             return single_cmd_val(ctx)
         if isinstance(single_cmd_val, str):
-            if self._auto_render_cmd:
+            if self._render_cmd:
                 return ctx.render(single_cmd_val)
             return single_cmd_val
         if isinstance(single_cmd_val, AnyCmdVal):

zrb/task/http_check.py

@@ -1,16 +1,14 @@
 import asyncio
 from collections.abc import Callable
 
-import requests
-
-from ..attr.type import StrAttr
-from ..context.any_context import AnyContext
-from ..context.context import Context
-from ..env.any_env import AnyEnv
-from ..input.any_input import AnyInput
-from ..util.attr import get_str_attr
-from .any_task import AnyTask
-from .base_task import BaseTask
+from zrb.attr.type import StrAttr
+from zrb.context.any_context import AnyContext
+from zrb.context.context import Context
+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_str_attr
 
 
 class HttpCheck(BaseTask):
@@ -24,7 +22,7 @@ class HttpCheck(BaseTask):
         input: list[AnyInput] | AnyInput | None = None,
         env: list[AnyEnv] | AnyEnv | None = None,
         url: StrAttr = "http://localhost",
-        auto_render_url: bool = True,
+        render_url: bool = True,
         http_method: StrAttr = "GET",
         interval: int = 5,
         execute_condition: bool | str | Callable[[Context], bool] = True,
@@ -45,19 +43,21 @@ class HttpCheck(BaseTask):
             fallback=fallback,
         )
         self._url = url
-        self._auto_render_url = auto_render_url
+        self._render_url = render_url
         self._http_method = http_method
         self._interval = interval
 
     def _get_url(self, ctx: AnyContext) -> str:
         return get_str_attr(
-            ctx, self._url, "http://localhost", auto_render=self._auto_render_url
+            ctx, self._url, "http://localhost", auto_render=self._render_url
         )
 
     def _get_http_method(self, ctx: AnyContext) -> str:
         return get_str_attr(ctx, self._http_method, "GET", auto_render=True).upper()
 
     async def _exec_action(self, ctx: AnyContext) -> bool:
+        import requests
+
         url = self._get_url(ctx)
         http_method = self._get_http_method(ctx)
         while True:

zrb/task/llm_task.py

@@ -0,0 +1,215 @@
+import json
+import os
+from collections.abc import Callable
+from typing import Any
+
+from pydantic import BaseModel
+
+from zrb.attr.type import StrAttr
+from zrb.config import LLM_MODEL, LLM_SYSTEM_PROMPT
+from zrb.context.any_context import AnyContext
+from zrb.context.any_shared_context import AnySharedContext
+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_str_attr
+from zrb.util.cli.style import stylize_faint
+from zrb.util.llm.tool import callable_to_tool_schema
+
+ListOfDict = list[dict[str, Any]]
+
+
+class AdditionalTool(BaseModel):
+    fn: Callable
+    name: str | None
+    description: str | None
+
+
+def scratchpad(thought: str) -> str:
+    """Use this tool to note your thought and planning"""
+    return thought
+
+
+class LLMTask(BaseTask):
+
+    def __init__(
+        self,
+        name: str,
+        color: int | None = None,
+        icon: str | None = None,
+        description: str | None = None,
+        cli_only: bool = False,
+        input: list[AnyInput | None] | AnyInput | None = None,
+        env: list[AnyEnv | None] | AnyEnv | None = None,
+        model: StrAttr | None = LLM_MODEL,
+        render_model: bool = True,
+        system_prompt: StrAttr | None = LLM_SYSTEM_PROMPT,
+        render_system_prompt: bool = True,
+        message: StrAttr | None = None,
+        tools: (
+            dict[str, Callable] | Callable[[AnySharedContext], dict[str, Callable]]
+        ) = {},
+        history: ListOfDict | Callable[[AnySharedContext], ListOfDict] = [],
+        history_file: StrAttr | None = None,
+        render_history_file: bool = True,
+        model_kwargs: (
+            dict[str, Any] | Callable[[AnySharedContext], dict[str, Any]]
+        ) = {},
+        execute_condition: bool | str | Callable[[AnySharedContext], bool] = True,
+        retries: int = 2,
+        retry_period: float = 0,
+        readiness_check: list[AnyTask] | AnyTask | None = None,
+        readiness_check_delay: float = 0.5,
+        readiness_check_period: float = 5,
+        readiness_failure_threshold: int = 1,
+        readiness_timeout: int = 60,
+        monitor_readiness: bool = False,
+        upstream: list[AnyTask] | AnyTask | None = None,
+        fallback: list[AnyTask] | AnyTask | None = None,
+    ):
+        super().__init__(
+            name=name,
+            color=color,
+            icon=icon,
+            description=description,
+            cli_only=cli_only,
+            input=input,
+            env=env,
+            execute_condition=execute_condition,
+            retries=retries,
+            retry_period=retry_period,
+            readiness_check=readiness_check,
+            readiness_check_delay=readiness_check_delay,
+            readiness_check_period=readiness_check_period,
+            readiness_failure_threshold=readiness_failure_threshold,
+            readiness_timeout=readiness_timeout,
+            monitor_readiness=monitor_readiness,
+            upstream=upstream,
+            fallback=fallback,
+        )
+        self._model = model
+        self._render_model = render_model
+        self._model_kwargs = model_kwargs
+        self._system_prompt = system_prompt
+        self._render_system_prompt = render_system_prompt
+        self._message = message
+        self._tools = tools
+        self._history = history
+        self._history_file = history_file
+        self._render_history_file = render_history_file
+        self._additional_tools: list[AdditionalTool] = []
+
+    def add_tool(
+        self, tool: Callable, name: str | None = None, description: str | None = None
+    ):
+        self._additional_tools.append(
+            AdditionalTool(fn=tool, name=name, description=description)
+        )
+
+    async def _exec_action(self, ctx: AnyContext) -> Any:
+        from litellm import acompletion
+
+        model_kwargs = self._get_model_kwargs(ctx)
+        ctx.log_debug("MODEL KWARGS", model_kwargs)
+        system_prompt = self._get_system_prompt(ctx)
+        ctx.log_debug("SYSTEM PROMPT", system_prompt)
+        history = self._get_history(ctx)
+        ctx.log_debug("HISTORY PROMPT", history)
+        user_message = {"role": "user", "content": self._get_message(ctx)}
+        ctx.print(stylize_faint(f"{user_message}"))
+        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
+                )
+            )
+        ctx.log_debug("TOOL SCHEMA", tool_schema)
+        history_file = self._get_history_file(ctx)
+        while True:
+            response = await acompletion(
+                model=self._get_model(ctx),
+                messages=[{"role": "system", "content": system_prompt}] + messages,
+                tools=tool_schema,
+                **model_kwargs,
+            )
+            response_message = response.choices[0].message
+            ctx.print(stylize_faint(f"{response_message.to_dict()}"))
+            messages.append(response_message.to_dict())
+            tool_calls = response_message.tool_calls
+            if tool_calls:
+                # noqa Reference: https://docs.litellm.ai/docs/completion/function_call#full-code---parallel-function-calling-with-gpt-35-turbo-1106
+                for tool_call in tool_calls:
+                    function_name = tool_call.function.name
+                    function_to_call = available_tools[function_name]
+                    function_kwargs = json.loads(tool_call.function.arguments)
+                    function_response = function_to_call(**function_kwargs)
+                    tool_call_message = {
+                        "tool_call_id": tool_call.id,
+                        "role": "tool",
+                        "name": function_name,
+                        "content": function_response,
+                    }
+                    ctx.print(stylize_faint(f"{tool_call_message}"))
+                    messages.append(tool_call_message)
+                continue
+            if history_file != "":
+                os.makedirs(os.path.dirname(history_file), exist_ok=True)
+                with open(history_file, "w") as f:
+                    f.write(json.dumps(messages, indent=2))
+            return response_message.content
+
+    def _get_model(self, ctx: AnyContext) -> str:
+        return get_str_attr(
+            ctx, self._model, "ollama_chat/llama3.1", auto_render=self._render_model
+        )
+
+    def _get_system_prompt(self, ctx: AnyContext) -> str:
+        return get_str_attr(
+            ctx,
+            self._system_prompt,
+            "You are a helpful assistant",
+            auto_render=self._render_system_prompt,
+        )
+
+    def _get_message(self, ctx: AnyContext) -> str:
+        return get_str_attr(ctx, self._message, "How are you?", auto_render=True)
+
+    def _get_model_kwargs(self, ctx: AnyContext) -> dict[str, Callable]:
+        if callable(self._model_kwargs):
+            return self._model_kwargs(ctx)
+        return self._model_kwargs
+
+    def _get_tools(self, ctx: AnyContext) -> dict[str, Callable]:
+        if callable(self._tools):
+            return self._tools(ctx)
+        return self._tools
+
+    def _get_history(self, ctx: AnyContext) -> ListOfDict:
+        if callable(self._history):
+            return self._history(ctx)
+        history_file = self._get_history_file(ctx)
+        if (
+            len(self._history) == 0
+            and history_file != ""
+            and os.path.isfile(history_file)
+        ):
+            with open(history_file, "r") as f:
+                return json.loads(f.read())
+        return self._history
+
+    def _get_history_file(self, ctx: AnyContext) -> str:
+        return get_str_attr(
+            ctx, self._history_file, "", auto_render=self._render_history_file
+        )

zrb/task/make_task.py

@@ -1,13 +1,13 @@
 from collections.abc import Callable
 from typing import Any
 
-from ..context.any_context import AnyContext
-from ..context.any_shared_context import AnySharedContext
-from ..env.any_env import AnyEnv
-from ..group.any_group import AnyGroup
-from ..input.any_input import AnyInput
-from .any_task import AnyTask
-from .base_task import BaseTask
+from zrb.context.any_context import AnyContext
+from zrb.context.any_shared_context import AnySharedContext
+from zrb.env.any_env import AnyEnv
+from zrb.group.any_group import AnyGroup
+from zrb.input.any_input import AnyInput
+from zrb.task.any_task import AnyTask
+from zrb.task.base_task import BaseTask
 
 
 def make_task(
@@ -16,8 +16,8 @@ def make_task(
     icon: str | None = None,
     description: str | None = None,
     cli_only: bool = False,
-    input: list[AnyInput] | AnyInput | None = None,
-    env: list[AnyEnv] | AnyEnv | None = None,
+    input: list[AnyInput | None] | AnyInput | None = None,
+    env: list[AnyEnv | None] | AnyEnv | None = None,
     execute_condition: bool | str | Callable[[AnySharedContext], bool] = True,
     retries: int = 2,
     retry_period: float = 0,

zrb/task/rsync_task.py

@@ -1,12 +1,12 @@
 from collections.abc import Callable
 
-from ..attr.type import IntAttr, StrAttr
-from ..context.any_context import AnyContext
-from ..env.any_env import AnyEnv
-from ..input.any_input import AnyInput
-from ..util.attr import get_str_attr
-from .any_task import AnyTask
-from .cmd_task import CmdTask
+from zrb.attr.type import IntAttr, StrAttr
+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.cmd_task import CmdTask
+from zrb.util.attr import get_str_attr
 
 
 class RsyncTask(CmdTask):
@@ -32,13 +32,13 @@ class RsyncTask(CmdTask):
         remote_ssh_key: StrAttr | None = None,
         auto_render_remote_ssh_key: bool = True,
         remote_source_path: StrAttr | None = None,
-        auto_render_remote_source_path: bool = True,
+        render_remote_source_path: bool = True,
         remote_destination_path: StrAttr | None = None,
-        auto_render_remote_destination_path: bool = True,
+        render_remote_destination_path: bool = True,
         local_source_path: StrAttr | None = None,
-        auto_render_local_source_path: bool = True,
+        render_local_source_path: bool = True,
         local_destination_path: StrAttr | None = None,
-        auto_render_local_destination_path: bool = True,
+        render_local_destination_path: bool = True,
         cwd: str | None = None,
         auto_render_cwd: bool = True,
         max_output_line: int = 1000,
@@ -59,19 +59,19 @@ class RsyncTask(CmdTask):
             input=input,
             env=env,
             shell=shell,
-            auto_render_shell=auto_render_shell,
+            render_shell=auto_render_shell,
             remote_host=remote_host,
-            auto_render_remote_host=auto_render_remote_host,
+            render_remote_host=auto_render_remote_host,
             remote_port=remote_port,
             auto_render_remote_port=auto_render_remote_port,
             remote_user=remote_user,
-            auto_render_remote_user=auto_render_remote_user,
+            render_remote_user=auto_render_remote_user,
             remote_password=remote_password,
-            auto_render_remote_password=auto_render_remote_password,
+            render_remote_password=auto_render_remote_password,
             remote_ssh_key=remote_ssh_key,
-            auto_render_remote_ssh_key=auto_render_remote_ssh_key,
+            render_remote_ssh_key=auto_render_remote_ssh_key,
             cwd=cwd,
-            auto_render_cwd=auto_render_cwd,
+            render_cwd=auto_render_cwd,
             max_output_line=max_output_line,
             max_error_line=max_error_line,
             execute_condition=execute_condition,
@@ -82,13 +82,13 @@ class RsyncTask(CmdTask):
             fallback=fallback,
         )
         self._remote_source_path = remote_source_path
-        self._auto_render_remote_source_path = auto_render_remote_source_path
+        self._render_remote_source_path = render_remote_source_path
         self._remote_destination_path = remote_destination_path
-        self._auto_render_remote_destination_path = auto_render_remote_destination_path
+        self._render_remote_destination_path = render_remote_destination_path
         self._local_source_path = local_source_path
-        self._auto_render_local_source_path = auto_render_local_source_path
+        self._render_local_source_path = render_local_source_path
         self._local_destination_path = local_destination_path
-        self._auto_render_local_destination_path = auto_render_local_destination_path
+        self._render_local_destination_path = render_local_destination_path
 
     def _get_source_path(self, ctx: AnyContext) -> str:
         local_source_path = self._get_local_source_path(ctx)
@@ -113,7 +113,7 @@ class RsyncTask(CmdTask):
             ctx,
             self._remote_source_path,
             "",
-            auto_render=self._auto_render_remote_source_path,
+            auto_render=self._render_remote_source_path,
         )
 
     def _get_remote_destination_path(self, ctx: AnyContext) -> str:
@@ -121,7 +121,7 @@ class RsyncTask(CmdTask):
             ctx,
             self._remote_destination_path,
             "",
-            auto_render=self._auto_render_remote_destination_path,
+            auto_render=self._render_remote_destination_path,
         )
 
     def _get_local_source_path(self, ctx: AnyContext) -> str:
@@ -129,7 +129,7 @@ class RsyncTask(CmdTask):
             ctx,
             self._local_source_path,
             "",
-            auto_render=self._auto_render_local_source_path,
+            auto_render=self._render_local_source_path,
         )
 
     def _get_local_destination_path(self, ctx: AnyContext) -> str:
@@ -137,7 +137,7 @@ class RsyncTask(CmdTask):
             ctx,
             self._local_destination_path,
             "",
-            auto_render=self._auto_render_local_destination_path,
+            auto_render=self._render_local_destination_path,
         )
 
     def _get_cmd_script(self, ctx: AnyContext) -> str: