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

zrb/session_state_logger/file_session_state_logger.py

@@ -1,9 +1,8 @@
 import datetime
-import json
 import os
 
-from ..session_state_log.session_state_log import SessionStateLog, SessionStateLogList
-from .any_session_state_logger import AnySessionStateLogger
+from zrb.session_state_log.session_state_log import SessionStateLog, SessionStateLogList
+from zrb.session_state_logger.any_session_state_logger import AnySessionStateLogger
 
 
 class FileSessionStateLogger(AnySessionStateLogger):
@@ -12,21 +11,24 @@ class FileSessionStateLogger(AnySessionStateLogger):
         self._session_log_dir = session_log_dir
 
     def write(self, session_log: SessionStateLog):
-        session_file_path = self._get_session_file_path(session_log["name"])
+        session_file_path = self._get_session_file_path(session_log.name)
+        session_dir_path = os.path.dirname(session_file_path)
+        if not os.path.isdir(session_dir_path):
+            os.makedirs(session_dir_path, exist_ok=True)
         with open(session_file_path, "w") as f:
-            f.write(json.dumps(session_log))
-        start_time = self._get_start_time(session_log)
-        if start_time is None:
+            f.write(session_log.model_dump_json())
+        start_time = session_log.start_time
+        if start_time == "":
             return
-        timeline_dir_path = self._get_timeline_dir_path(session_log, start_time)
+        timeline_dir_path = self._get_timeline_dir_path(session_log)
         os.makedirs(timeline_dir_path, exist_ok=True)
-        with open(os.path.join(timeline_dir_path, session_log["name"]), "w"):
+        with open(os.path.join(timeline_dir_path, session_log.name), "w"):
             pass
 
     def read(self, session_name: str) -> SessionStateLog:
         session_file_path = self._get_session_file_path(session_name)
         with open(session_file_path, "r") as f:
-            return json.loads(f.read())
+            return SessionStateLog.model_validate_json(f.read())
 
     def list(
         self,
@@ -59,21 +61,20 @@ class FileSessionStateLogger(AnySessionStateLogger):
         paginated_sessions = matching_sessions[start_index:end_index]
         # Extract session logs from the sorted list of tuples
         data = [session_log for _, session_log in paginated_sessions]
-        return {"total": total, "data": data}
+        return SessionStateLogList(total=total, data=data)
 
     def _get_session_file_path(self, session_name: str) -> str:
         return os.path.join(self._session_log_dir, f"{session_name}.json")
 
-    def _get_timeline_dir_path(
-        self, session_log: SessionStateLog, start_time: datetime.datetime
-    ) -> str:
+    def _get_timeline_dir_path(self, session_log: SessionStateLog) -> str:
+        start_time = self._get_start_time(session_log)
         year = start_time.year
         month = start_time.month
         day = start_time.day
         hour = start_time.hour
         minute = start_time.minute
         second = start_time.second
-        paths = session_log["path"] + [
+        paths = session_log.path + [
             f"{year}",
             f"{month}",
             f"{day}",
@@ -84,15 +85,6 @@ class FileSessionStateLogger(AnySessionStateLogger):
         return os.path.join(self._session_log_dir, "_timeline", *paths)
 
     def _get_start_time(self, session_log: SessionStateLog) -> datetime.datetime:
-        result: datetime.datetime | None = None
-        for task_status in session_log["task_status"].values():
-            histories = task_status["history"]
-            if len(histories) == 0:
-                continue
-            first_history = histories[0]
-            first_time = datetime.datetime.strptime(
-                first_history["time"], "%Y-%m-%d %H:%M:%S.%f"
-            )
-            if result is None or first_time < result:
-                result = first_time
-        return result
+        return datetime.datetime.strptime(
+            session_log.start_time, "%Y-%m-%d %H:%M:%S.%f"
+        )

zrb/task/any_task.py

@@ -3,12 +3,12 @@ from __future__ import annotations  # Enables forward references
 from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, Any
 
-from ..env.any_env import AnyEnv
-from ..input.any_input import AnyInput
+from zrb.env.any_env import AnyEnv
+from zrb.input.any_input import AnyInput
 
 if TYPE_CHECKING:
-    from ..context import any_context
-    from ..session import session
+    from zrb.context import any_context
+    from zrb.session import session
 
 
 class AnyTask(ABC):

zrb/task/base_task.py

@@ -3,17 +3,17 @@ import os
 from collections.abc import Callable
 from typing import Any
 
-from ..attr.type import BoolAttr, fstring
-from ..context.any_context import AnyContext
-from ..context.shared_context import AnySharedContext, SharedContext
-from ..env.any_env import AnyEnv
-from ..input.any_input import AnyInput
-from ..session.any_session import AnySession
-from ..session.session import Session
-from ..util.attr import get_bool_attr
-from ..util.run import run_async
-from ..xcom.xcom import Xcom
-from .any_task import AnyTask
+from zrb.attr.type import BoolAttr, fstring
+from zrb.context.any_context import AnyContext
+from zrb.context.shared_context import AnySharedContext, SharedContext
+from zrb.env.any_env import AnyEnv
+from zrb.input.any_input import AnyInput
+from zrb.session.any_session import AnySession
+from zrb.session.session import Session
+from zrb.task.any_task import AnyTask
+from zrb.util.attr import get_bool_attr
+from zrb.util.run import run_async
+from zrb.xcom.xcom import Xcom
 
 
 class BaseTask(AnyTask):
@@ -24,8 +24,8 @@ class BaseTask(AnyTask):
         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,
         action: fstring | Callable[[AnyContext], Any] | None = None,
         execute_condition: BoolAttr = True,
         retries: int = 2,
@@ -63,16 +63,22 @@ class BaseTask(AnyTask):
         return f"<{self.__class__.__name__} name={self._name}>"
 
     def __rshift__(self, other: AnyTask | list[AnyTask]) -> AnyTask:
-        if isinstance(other, AnyTask):
-            other.append_upstreams(self)
-        elif isinstance(other, list):
-            for task in other:
-                task.append_upstreams(self)
-        return other
+        try:
+            if isinstance(other, AnyTask):
+                other.append_upstreams(self)
+            elif isinstance(other, list):
+                for task in other:
+                    task.append_upstreams(self)
+            return other
+        except Exception as e:
+            raise ValueError(f"Invalid operation {self} >> {other}: {e}")
 
     def __lshift__(self, other: AnyTask | list[AnyTask]) -> AnyTask:
-        self.append_upstreams(other)
-        return self
+        try:
+            self.append_upstreams(other)
+            return self
+        except Exception as e:
+            raise ValueError(f"Invalid operation {self} << {other}: {e}")
 
     @property
     def name(self) -> str:
@@ -103,7 +109,7 @@ class BaseTask(AnyTask):
             envs.append(self._envs)
         elif self._envs is not None:
             envs += self._envs
-        return envs
+        return [env for env in envs if env is not None]
 
     @property
     def inputs(self) -> list[AnyInput]:
@@ -112,7 +118,7 @@ class BaseTask(AnyTask):
             self.__combine_inputs(inputs, upstream.inputs)
         if self._inputs is not None:
             self.__combine_inputs(inputs, self._inputs)
-        return inputs
+        return [task_input for task_input in inputs if task_input is not None]
 
     def __combine_inputs(
         self, inputs: list[AnyInput], other_inputs: list[AnyInput] | AnyInput
@@ -120,7 +126,11 @@ class BaseTask(AnyTask):
         input_names = [task_input.name for task_input in inputs]
         if isinstance(other_inputs, AnyInput):
             other_inputs = [other_inputs]
+        elif other_inputs is None:
+            other_inputs = []
         for task_input in other_inputs:
+            if task_input is None:
+                continue
             if task_input.name not in input_names:
                 inputs.append(task_input)
 

zrb/task/base_trigger.py

@@ -2,21 +2,20 @@ import asyncio
 from collections.abc import Callable
 from typing import Any
 
+from zrb.attr.type import fstring
+from zrb.callback.any_callback import AnyCallback
 from zrb.context.any_context import AnyContext
 from zrb.context.any_shared_context import AnySharedContext
+from zrb.context.shared_context import SharedContext
+from zrb.dot_dict.dot_dict import DotDict
 from zrb.env.any_env import AnyEnv
 from zrb.input.any_input import AnyInput
+from zrb.session.any_session import AnySession
+from zrb.session.session import Session
 from zrb.task.any_task import AnyTask
-
-from ..attr.type import fstring
-from ..callback.any_callback import AnyCallback
-from ..context.shared_context import SharedContext
-from ..dot_dict.dot_dict import DotDict
-from ..session.any_session import AnySession
-from ..session.session import Session
-from ..util.cli.style import CYAN
-from ..xcom.xcom import Xcom
-from .base_task import BaseTask
+from zrb.task.base_task import BaseTask
+from zrb.util.cli.style import CYAN
+from zrb.xcom.xcom import Xcom
 
 
 class BaseTrigger(BaseTask):
@@ -28,8 +27,8 @@ class BaseTrigger(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,
         action: fstring | Callable[[AnyContext], Any] | None = None,
         execute_condition: bool | str | Callable[[AnySharedContext], bool] = True,
         queue_name: fstring | None = None,

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,8 +23,8 @@ 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,
         shell_flag: StrAttr | None = None,
@@ -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):

zrb/task/http_check.py

@@ -3,14 +3,14 @@ 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):

zrb/task/llm_task.py

@@ -0,0 +1,160 @@
+import json
+from collections.abc import Callable
+from typing import Any
+
+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.llm.tool import callable_to_tool_schema
+
+DictList = list[dict[str, Any]]
+
+
+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,
+        system_prompt: StrAttr | None = LLM_SYSTEM_PROMPT,
+        message: StrAttr | None = None,
+        tools: (
+            dict[str, Callable] | Callable[[AnySharedContext], dict[str, Callable]]
+        ) = {},
+        tool_schema: DictList | Callable[[AnySharedContext], DictList] = [],
+        history: DictList | Callable[[AnySharedContext], DictList] = [],
+        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._system_prompt = system_prompt
+        self._message = message
+        self._tools = tools
+        self._tool_schema = tool_schema
+        self._history = history
+
+    async def _exec_action(self, ctx: AnyContext) -> Any:
+        from litellm import completion
+
+        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 = self._get_message(ctx)
+        ctx.log_debug("USER MESSAGE", user_message)
+        messages = (
+            [{"role": "system", "content": system_prompt}]
+            + history
+            + [{"role": "user", "content": user_message}]
+        )
+        available_tools = self._get_tools(ctx)
+        available_tools["scratchpad"] = scratchpad
+        tool_schema = self._get_tool_schema(ctx)
+        for tool_name, tool in available_tools.items():
+            matched_tool_schema = [
+                schema
+                for schema in tool_schema
+                if "function" in schema
+                and "name" in schema["function"]
+                and schema["function"]["name"] == tool_name
+            ]
+            if len(matched_tool_schema) == 0:
+                tool_schema.append(callable_to_tool_schema(tool))
+        ctx.log_debug("TOOL SCHEMA", tool_schema)
+        while True:
+            response = completion(
+                model=self._get_model(ctx), messages=messages, tools=tool_schema
+            )
+            response_message = response.choices[0].message
+            ctx.print(response_message)
+            messages.append(response_message)
+            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(tool_call_message)
+                    messages.append(tool_call_message)
+                continue
+            return response_message.content
+
+    def _get_model(self, ctx: AnyContext) -> str:
+        return get_str_attr(ctx, self._model, "ollama_chat/llama3.1", auto_render=True)
+
+    def _get_system_prompt(self, ctx: AnyContext) -> str:
+        return get_str_attr(
+            ctx, self._system_prompt, "You are a helpful assistant", auto_render=True
+        )
+
+    def _get_message(self, ctx: AnyContext) -> str:
+        return get_str_attr(ctx, self._message, "How are you?", auto_render=True)
+
+    def _get_tools(self, ctx: AnyContext) -> dict[str, Callable]:
+        if callable(self._tools):
+            return self._tools(ctx)
+        return self._tools
+
+    def _get_tool_schema(self, ctx: AnyContext) -> DictList:
+        if callable(self._tool_schema):
+            return self._tool_schema(ctx)
+        return self._tool_schema
+
+    def _get_history(self, ctx: AnyContext) -> DictList:
+        if callable(self._history):
+            return self._history(ctx)
+        return self._history

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):

zrb/task/scaffolder.py

@@ -2,15 +2,15 @@ import os
 import shutil
 from collections.abc import Callable
 
-from ..attr.type import BoolAttr, StrAttr
-from ..content_transformer.any_content_transformer import AnyContentTransformer
-from ..content_transformer.content_transformer import ContentTransformer
-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 .base_task import BaseTask
+from zrb.attr.type import BoolAttr, StrAttr
+from zrb.content_transformer.any_content_transformer import AnyContentTransformer
+from zrb.content_transformer.content_transformer import ContentTransformer
+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_str_attr
 
 TransformConfig = dict[str, str] | Callable[[AnyContext, str], str]
 
@@ -96,7 +96,10 @@ class Scaffolder(BaseTask):
         for file_path in file_paths:
             for transformer in transformers:
                 if transformer.match(ctx, file_path):
-                    transformer.transform_file(ctx, file_path)
+                    try:
+                        transformer.transform_file(ctx, file_path)
+                    except UnicodeDecodeError:
+                        pass
 
     def _copy_path(self, ctx: AnyContext, source_path: str, destination_path: str):
         """
@@ -119,7 +122,7 @@ class Scaffolder(BaseTask):
         else:
             dest_file = os.path.join(
                 destination_path,
-                self._transform_path(os.path.basename(ctx, source_path)),
+                self._transform_path(ctx, os.path.basename(source_path)),
             )
             shutil.copy2(source_path, dest_file)
             ctx.log_info(f"Copied and renamed {source_path} to {dest_file}")