zrb 1.15.3__py3-none-any.whl → 2.0.0a4__py3-none-any.whl

zrb/task/base/context.py

@@ -1,5 +1,5 @@
 import os
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 from zrb.context.any_context import AnyContext
 from zrb.context.any_shared_context import AnySharedContext
@@ -26,25 +26,33 @@ def build_task_context(task: AnyTask, session: AnySession) -> AnyContext:
 
 
 def fill_shared_context_inputs(
-    task: AnyTask, shared_context: AnySharedContext, str_kwargs: dict[str, str] = {}
+    shared_ctx: AnySharedContext,
+    task: AnyTask,
+    str_kwargs: dict[str, str] | None = None,
+    kwargs: dict[str, Any] | None = None,
 ):
     """
-    Populates the shared context with input values provided via kwargs.
+    Populates the shared context with input values provided via str_kwargs.
     """
+    str_kwarg_dict = str_kwargs if str_kwargs is not None else {}
+    kwarg_dict = kwargs if kwargs is not None else {}
     for task_input in task.inputs:
-        if task_input.name not in shared_context.input:
-            str_value = str_kwargs.get(task_input.name, None)
-            task_input.update_shared_context(shared_context, str_value)
+        if task_input.name not in shared_ctx.input:
+            task_input.update_shared_context(
+                shared_ctx,
+                value=kwarg_dict.get(task_input.name, None),
+                str_value=str_kwarg_dict.get(task_input.name, None),
+            )
 
 
-def fill_shared_context_envs(shared_context: AnySharedContext):
+def fill_shared_context_envs(shared_ctx: AnySharedContext):
     """
     Injects OS environment variables into the shared context if they don't already exist.
     """
     os_env_map = {
-        key: val for key, val in os.environ.items() if key not in shared_context.env
+        key: val for key, val in os.environ.items() if key not in shared_ctx.env
     }
-    shared_context.env.update(os_env_map)
+    shared_ctx.env.update(os_env_map)
 
 
 def combine_inputs(
@@ -71,24 +79,36 @@ def combine_inputs(
             input_names.append(task_input.name)  # Update names list
 
 
+def combine_envs(
+    existing_envs: list[AnyEnv],
+    new_envs: list[AnyEnv | None] | AnyEnv | None,
+):
+    """
+    Combines new envs into an existing list.
+    Modifies the existing_envs list in place.
+    """
+    if isinstance(new_envs, AnyEnv):
+        existing_envs.append(new_envs)
+    elif new_envs is None:
+        pass
+    else:
+        # new_envs is a list
+        for env in new_envs:
+            if env is not None:
+                existing_envs.append(env)
+
+
 def get_combined_envs(task: "BaseTask") -> list[AnyEnv]:
     """
     Aggregates environment variables from the task and its upstreams.
     """
-    envs = []
+    envs: list[AnyEnv] = []
     for upstream in task.upstreams:
-        envs.extend(upstream.envs)  # Use extend for list concatenation
-
-    # Access _envs directly as task is BaseTask
-    task_envs: list[AnyEnv | None] | AnyEnv | None = task._envs
-    if isinstance(task_envs, AnyEnv):
-        envs.append(task_envs)
-    elif isinstance(task_envs, list):
-        # Filter out None while extending
-        envs.extend(env for env in task_envs if env is not None)
-
-    # Filter out None values efficiently from the combined list
-    return [env for env in envs if env is not None]
+        combine_envs(envs, upstream.envs)
+
+    combine_envs(envs, task._envs)
+
+    return envs
 
 
 def get_combined_inputs(task: "BaseTask") -> list[AnyInput]:

zrb/task/base/execution.py

@@ -53,7 +53,9 @@ def check_execute_condition(task: "BaseTask", session: AnySession) -> bool:
     Evaluates the task's execute_condition attribute.
     """
     ctx = task.get_ctx(session)
-    execute_condition_attr = getattr(task, "_execute_condition", True)
+    execute_condition_attr = (
+        task._execute_condition if task._execute_condition is not None else True
+    )
     return get_bool_attr(ctx, execute_condition_attr, True, auto_render=True)
 
 
@@ -63,8 +65,12 @@ async def execute_action_until_ready(task: "BaseTask", session: AnySession):
     """
     ctx = task.get_ctx(session)
     readiness_checks = task.readiness_checks
-    readiness_check_delay = getattr(task, "_readiness_check_delay", 0.5)
-    monitor_readiness = getattr(task, "_monitor_readiness", False)
+    readiness_check_delay = (
+        task._readiness_check_delay if task._readiness_check_delay is not None else 0.5
+    )
+    monitor_readiness = (
+        task._monitor_readiness if task._monitor_readiness is not None else False
+    )
 
     if not readiness_checks:  # Simplified check for empty list
         ctx.log_info("No readiness checks")
@@ -82,56 +88,61 @@ async def execute_action_until_ready(task: "BaseTask", session: AnySession):
         run_async(execute_action_with_retry(task, session))
     )
 
-    await asyncio.sleep(readiness_check_delay)
-
-    readiness_check_coros = [
-        run_async(check.exec_chain(session)) for check in readiness_checks
-    ]
-
-    # Wait primarily for readiness checks to complete
-    ctx.log_info("Waiting for readiness checks")
-    readiness_passed = False
     try:
-        # Gather results, but primarily interested in completion/errors
-        await asyncio.gather(*readiness_check_coros)
-        # Check if all readiness tasks actually completed successfully
-        all_readiness_completed = all(
-            session.get_task_status(check).is_completed for check in readiness_checks
-        )
-        if all_readiness_completed:
-            ctx.log_info("Readiness checks completed successfully")
-            readiness_passed = True
-            # Mark task as ready only if checks passed and action didn't fail during checks
-            if not session.get_task_status(task).is_failed:
-                ctx.log_info("Marked as ready")
-                session.get_task_status(task).mark_as_ready()
-        else:
-            ctx.log_warning(
-                "One or more readiness checks did not complete successfully."
-            )
-
-    except Exception as e:
-        ctx.log_error(f"Readiness check failed with exception: {e}")
-        # If readiness checks fail with an exception, the task is not ready.
-        # The action_coro might still be running or have failed.
-        # execute_action_with_retry handles marking the main task status.
+        await asyncio.sleep(readiness_check_delay)
 
-    # Defer the main action coroutine; it will be awaited later if needed
-    session.defer_action(task, action_coro)
-
-    # Start monitoring only if readiness passed and monitoring is enabled
-    if readiness_passed and monitor_readiness:
-        # Import dynamically to avoid circular dependency if monitoring imports execution
-        from zrb.task.base.monitoring import monitor_task_readiness
+        readiness_check_coros = [
+            run_async(check.exec_chain(session)) for check in readiness_checks
+        ]
 
-        monitor_coro = asyncio.create_task(
-            run_async(monitor_task_readiness(task, session, action_coro))
-        )
-        session.defer_monitoring(task, monitor_coro)
+        # Wait primarily for readiness checks to complete
+        ctx.log_info("Waiting for readiness checks")
+        readiness_passed = False
+        try:
+            # Gather results, but primarily interested in completion/errors
+            await asyncio.gather(*readiness_check_coros)
+            # Check if all readiness tasks actually completed successfully
+            all_readiness_completed = all(
+                session.get_task_status(check).is_completed
+                for check in readiness_checks
+            )
+            if all_readiness_completed:
+                ctx.log_info("Readiness checks completed successfully")
+                readiness_passed = True
+                # Mark task as ready only if checks passed and action didn't fail during checks
+                if not session.get_task_status(task).is_failed:
+                    ctx.log_info("Marked as ready")
+                    session.get_task_status(task).mark_as_ready()
+            else:
+                ctx.log_warning(
+                    "One or more readiness checks did not complete successfully."
+                )
+
+        except Exception as e:
+            ctx.log_error(f"Readiness check failed with exception: {e}")
+            # If readiness checks fail with an exception, the task is not ready.
+            # The action_coro might still be running or have failed.
+            # execute_action_with_retry handles marking the main task status.
+
+        # Defer the main action coroutine; it will be awaited later if needed
+        session.defer_action(task, action_coro)
+
+        # Start monitoring only if readiness passed and monitoring is enabled
+        if readiness_passed and monitor_readiness:
+            # Import dynamically to avoid circular dependency if monitoring imports execution
+            from zrb.task.base.monitoring import monitor_task_readiness
+
+            monitor_coro = asyncio.create_task(
+                run_async(monitor_task_readiness(task, session, action_coro))
+            )
+            session.defer_monitoring(task, monitor_coro)
 
-    # The result here is primarily about readiness check completion.
-    # The actual task result is handled by the deferred action_coro.
-    return None
+        # The result here is primarily about readiness check completion.
+        # The actual task result is handled by the deferred action_coro.
+        return None
+    except (asyncio.CancelledError, KeyboardInterrupt, GeneratorExit):
+        action_coro.cancel()
+        raise
 
 
 async def execute_action_with_retry(task: "BaseTask", session: AnySession) -> Any:
@@ -140,8 +151,8 @@ async def execute_action_with_retry(task: "BaseTask", session: AnySession) -> An
     handling success (triggering successors) and failure (triggering fallbacks).
     """
     ctx = task.get_ctx(session)
-    retries = getattr(task, "_retries", 2)
-    retry_period = getattr(task, "_retry_period", 0)
+    retries = task._retries if task._retries is not None else 2
+    retry_period = task._retry_period if task._retry_period is not None else 0
     max_attempt = retries + 1
     ctx.set_max_attempt(max_attempt)
 
@@ -163,15 +174,16 @@ async def execute_action_with_retry(task: "BaseTask", session: AnySession) -> An
             session.get_task_status(task).mark_as_completed()
 
             # Store result in XCom
-            task_xcom: Xcom = ctx.xcom.get(task.name)
-            task_xcom.push(result)
+            task_xcom: Xcom | None = ctx.xcom.get(task.name)
+            if task_xcom is not None:
+                task_xcom.push(result)
 
             # Skip fallbacks and execute successors on success
             skip_fallbacks(task, session)
             await run_async(execute_successors(task, session))
             return result
 
-        except (asyncio.CancelledError, KeyboardInterrupt):
+        except (asyncio.CancelledError, KeyboardInterrupt, GeneratorExit):
             ctx.log_warning("Task cancelled or interrupted")
             session.get_task_status(task).mark_as_failed()  # Mark as failed on cancel
             # Do not trigger fallbacks/successors on cancellation
@@ -201,7 +213,7 @@ async def run_default_action(task: "BaseTask", ctx: AnyContext) -> Any:
     This is the default implementation called by BaseTask._exec_action.
     Subclasses like LLMTask override _exec_action with their own logic.
     """
-    action = getattr(task, "_action", None)
+    action = task._action
     if action is None:
         ctx.log_debug("No action defined for this task.")
         return None

zrb/task/base/lifecycle.py

@@ -1,6 +1,7 @@
 import asyncio
 from typing import Any
 
+from zrb.context.print_fn import PrintFn
 from zrb.context.shared_context import SharedContext
 from zrb.session.any_session import AnySession
 from zrb.session.session import Session
@@ -12,7 +13,9 @@ from zrb.util.run import run_async
 async def run_and_cleanup(
     task: AnyTask,
     session: AnySession | None = None,
-    str_kwargs: dict[str, str] = {},
+    print_fn: PrintFn | None = None,
+    str_kwargs: dict[str, str] | None = None,
+    kwargs: dict[str, Any] | None = None,
 ) -> Any:
     """
     Wrapper for async_run that ensures session termination and cleanup of
@@ -20,10 +23,12 @@ async def run_and_cleanup(
     """
     # Ensure a session exists
     if session is None:
-        session = Session(shared_ctx=SharedContext())
+        session = Session(shared_ctx=SharedContext(print_fn=print_fn))
 
     # Create the main task execution coroutine
-    main_task_coro = asyncio.create_task(run_task_async(task, session, str_kwargs))
+    main_task_coro = asyncio.create_task(
+        run_task_async(task, session, print_fn, str_kwargs, kwargs)
+    )
 
     try:
         result = await main_task_coro
@@ -67,17 +72,19 @@ async def run_and_cleanup(
 async def run_task_async(
     task: AnyTask,
     session: AnySession | None = None,
-    str_kwargs: dict[str, str] = {},
+    print_fn: PrintFn | None = None,
+    str_kwargs: dict[str, str] | None = None,
+    kwargs: dict[str, Any] | None = None,
 ) -> Any:
     """
     Asynchronous entry point for running a task (`task.async_run()`).
     Sets up the session and initiates the root task execution chain.
     """
     if session is None:
-        session = Session(shared_ctx=SharedContext())
+        session = Session(shared_ctx=SharedContext(print_fn=print_fn))
 
     # Populate shared context with inputs and environment variables
-    fill_shared_context_inputs(task, session.shared_ctx, str_kwargs)
+    fill_shared_context_inputs(session.shared_ctx, task, str_kwargs, kwargs)
     fill_shared_context_envs(session.shared_ctx)  # Inject OS env vars
 
     # Start the execution chain from the root tasks
@@ -172,7 +179,7 @@ async def log_session_state(task: AnyTask, session: AnySession):
     try:
         while not session.is_terminated:
             session.state_logger.write(session.as_state_log())
-            await asyncio.sleep(0.1)  # Log interval
+            await asyncio.sleep(0)  # Log interval
         # Log one final time after termination signal
         session.state_logger.write(session.as_state_log())
     except asyncio.CancelledError:

zrb/task/base/monitoring.py

@@ -17,9 +17,13 @@ async def monitor_task_readiness(
     """
     ctx = task.get_ctx(session)
     readiness_checks = task.readiness_checks
-    readiness_check_period = getattr(task, "_readiness_check_period", 5.0)
-    readiness_failure_threshold = getattr(task, "_readiness_failure_threshold", 1)
-    readiness_timeout = getattr(task, "_readiness_timeout", 60)
+    readiness_check_period = (
+        task._readiness_check_period if task._readiness_check_period else 5.0
+    )
+    readiness_failure_threshold = (
+        task._readiness_failure_threshold if task._readiness_failure_threshold else 1
+    )
+    readiness_timeout = task._readiness_timeout if task._readiness_timeout else 60
 
     if not readiness_checks:
         ctx.log_debug("No readiness checks defined, monitoring is not applicable.")
@@ -41,8 +45,9 @@ async def monitor_task_readiness(
                 session.get_task_status(check).reset_history()
                 session.get_task_status(check).reset()
                 # Clear previous XCom data for the check task if needed
-                check_xcom: Xcom = ctx.xcom.get(check.name)
-                check_xcom.clear()
+                check_xcom: Xcom | None = ctx.xcom.get(check.name)
+                if check_xcom is not None:
+                    check_xcom.clear()
 
             readiness_check_coros = [
                 run_async(check.exec_chain(session)) for check in readiness_checks
@@ -77,7 +82,7 @@ async def monitor_task_readiness(
                 )
                 # Ensure check tasks are marked as failed on timeout
                 for check in readiness_checks:
-                    if not session.get_task_status(check).is_finished:
+                    if not session.get_task_status(check).is_ready:
                         session.get_task_status(check).mark_as_failed()
 
             except (asyncio.CancelledError, KeyboardInterrupt):
@@ -92,7 +97,7 @@ async def monitor_task_readiness(
                 )
                 # Mark checks as failed
                 for check in readiness_checks:
-                    if not session.get_task_status(check).is_finished:
+                    if not session.get_task_status(check).is_ready:
                         session.get_task_status(check).mark_as_failed()
 
         # If failure threshold is reached

zrb/task/base_task.py

@@ -3,8 +3,9 @@ import inspect
 from collections.abc import Callable
 from typing import Any
 
-from zrb.attr.type import BoolAttr, fstring
+from zrb.attr.type import fstring
 from zrb.context.any_context import AnyContext
+from zrb.context.print_fn import PrintFn
 from zrb.env.any_env import AnyEnv
 from zrb.input.any_input import AnyInput
 from zrb.session.any_session import AnySession
@@ -21,6 +22,7 @@ from zrb.task.base.execution import (
 )
 from zrb.task.base.lifecycle import execute_root_tasks, run_and_cleanup, run_task_async
 from zrb.task.base.operators import handle_lshift, handle_rshift
+from zrb.util.string.conversion import to_snake_case
 
 
 class BaseTask(AnyTask):
@@ -54,7 +56,7 @@ class BaseTask(AnyTask):
         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,
+        execute_condition: bool | str | Callable[[AnyContext], bool] = True,
         retries: int = 2,
         retry_period: float = 0,
         readiness_check: list[AnyTask] | AnyTask | None = None,
@@ -66,10 +68,20 @@ class BaseTask(AnyTask):
         upstream: list[AnyTask] | AnyTask | None = None,
         fallback: list[AnyTask] | AnyTask | None = None,
         successor: list[AnyTask] | AnyTask | None = None,
+        print_fn: PrintFn | None = None,
     ):
-        caller_frame = inspect.stack()[1]
-        self.__decl_file = caller_frame.filename
-        self.__decl_line = caller_frame.lineno
+        # Optimized stack retrieval
+        frame = inspect.currentframe()
+        if frame is not None:
+            caller_frame = frame.f_back
+            self.__decl_file = (
+                caller_frame.f_code.co_filename if caller_frame else "unknown"
+            )
+            self.__decl_line = caller_frame.f_lineno if caller_frame else 0
+        else:
+            self.__decl_file = "unknown"
+            self.__decl_line = 0
+
         self._name = name
         self._color = color
         self._icon = icon
@@ -79,10 +91,10 @@ class BaseTask(AnyTask):
         self._envs = env
         self._retries = retries
         self._retry_period = retry_period
-        self._upstreams = upstream
-        self._fallbacks = fallback
-        self._successors = successor
-        self._readiness_checks = readiness_check
+        self._upstreams = self._ensure_task_list(upstream)
+        self._fallbacks = self._ensure_task_list(fallback)
+        self._successors = self._ensure_task_list(successor)
+        self._readiness_checks = self._ensure_task_list(readiness_check)
         self._readiness_check_delay = readiness_check_delay
         self._readiness_check_period = readiness_check_period
         self._readiness_failure_threshold = readiness_failure_threshold
@@ -90,6 +102,14 @@ class BaseTask(AnyTask):
         self._monitor_readiness = monitor_readiness
         self._execute_condition = execute_condition
         self._action = action
+        self._print_fn = print_fn
+
+    def _ensure_task_list(self, tasks: AnyTask | list[AnyTask] | None) -> list[AnyTask]:
+        if tasks is None:
+            return []
+        if isinstance(tasks, list):
+            return tasks
+        return [tasks]
 
     def __repr__(self):
         return f"<{self.__class__.__name__} name={self.name}>"
@@ -131,18 +151,10 @@ class BaseTask(AnyTask):
     @property
     def fallbacks(self) -> list[AnyTask]:
         """Returns the list of fallback tasks."""
-        if self._fallbacks is None:
-            return []
-        elif isinstance(self._fallbacks, list):
-            return self._fallbacks
-        return [self._fallbacks]  # Assume single task
+        return self._fallbacks
 
     def append_fallback(self, fallbacks: AnyTask | list[AnyTask]):
         """Appends fallback tasks, ensuring no duplicates."""
-        if self._fallbacks is None:
-            self._fallbacks = []
-        elif not isinstance(self._fallbacks, list):
-            self._fallbacks = [self._fallbacks]
         to_add = fallbacks if isinstance(fallbacks, list) else [fallbacks]
         for fb in to_add:
             if fb not in self._fallbacks:
@@ -151,18 +163,10 @@ class BaseTask(AnyTask):
     @property
     def successors(self) -> list[AnyTask]:
         """Returns the list of successor tasks."""
-        if self._successors is None:
-            return []
-        elif isinstance(self._successors, list):
-            return self._successors
-        return [self._successors]  # Assume single task
+        return self._successors
 
     def append_successor(self, successors: AnyTask | list[AnyTask]):
         """Appends successor tasks, ensuring no duplicates."""
-        if self._successors is None:
-            self._successors = []
-        elif not isinstance(self._successors, list):
-            self._successors = [self._successors]
         to_add = successors if isinstance(successors, list) else [successors]
         for succ in to_add:
             if succ not in self._successors:
@@ -171,18 +175,10 @@ class BaseTask(AnyTask):
     @property
     def readiness_checks(self) -> list[AnyTask]:
         """Returns the list of readiness check tasks."""
-        if self._readiness_checks is None:
-            return []
-        elif isinstance(self._readiness_checks, list):
-            return self._readiness_checks
-        return [self._readiness_checks]  # Assume single task
+        return self._readiness_checks
 
     def append_readiness_check(self, readiness_checks: AnyTask | list[AnyTask]):
         """Appends readiness check tasks, ensuring no duplicates."""
-        if self._readiness_checks is None:
-            self._readiness_checks = []
-        elif not isinstance(self._readiness_checks, list):
-            self._readiness_checks = [self._readiness_checks]
         to_add = (
             readiness_checks
             if isinstance(readiness_checks, list)
@@ -195,18 +191,10 @@ class BaseTask(AnyTask):
     @property
     def upstreams(self) -> list[AnyTask]:
         """Returns the list of upstream tasks."""
-        if self._upstreams is None:
-            return []
-        elif isinstance(self._upstreams, list):
-            return self._upstreams
-        return [self._upstreams]  # Assume single task
+        return self._upstreams
 
     def append_upstream(self, upstreams: AnyTask | list[AnyTask]):
         """Appends upstream tasks, ensuring no duplicates."""
-        if self._upstreams is None:
-            self._upstreams = []
-        elif not isinstance(self._upstreams, list):
-            self._upstreams = [self._upstreams]
         to_add = upstreams if isinstance(upstreams, list) else [upstreams]
         for up in to_add:
             if up not in self._upstreams:
@@ -216,7 +204,10 @@ class BaseTask(AnyTask):
         return build_task_context(self, session)
 
     def run(
-        self, session: AnySession | None = None, str_kwargs: dict[str, str] = {}
+        self,
+        session: AnySession | None = None,
+        str_kwargs: dict[str, str] | None = None,
+        kwargs: dict[str, Any] | None = None,
     ) -> Any:
         """
         Synchronously runs the task and its dependencies, handling async setup and cleanup.
@@ -235,12 +226,29 @@ class BaseTask(AnyTask):
             Any: The final result of the main task execution.
         """
         # Use asyncio.run() to execute the async cleanup wrapper
-        return asyncio.run(run_and_cleanup(self, session, str_kwargs))
+        return asyncio.run(
+            run_and_cleanup(
+                self,
+                session=session,
+                print_fn=self._print_fn,
+                str_kwargs=str_kwargs,
+                kwargs=kwargs,
+            )
+        )
 
     async def async_run(
-        self, session: AnySession | None = None, str_kwargs: dict[str, str] = {}
+        self,
+        session: AnySession | None = None,
+        str_kwargs: dict[str, str] | None = None,
+        kwargs: dict[str, Any] | None = None,
     ) -> Any:
-        return await run_task_async(self, session, str_kwargs)
+        return await run_task_async(
+            self,
+            session=session,
+            print_fn=self._print_fn,
+            str_kwargs=str_kwargs,
+            kwargs=kwargs,
+        )
 
     async def exec_root_tasks(self, session: AnySession):
         return await execute_root_tasks(self, session)
@@ -266,6 +274,8 @@ class BaseTask(AnyTask):
         try:
             # Delegate to the helper function for the default behavior
             return await run_default_action(self, ctx)
+        except (KeyboardInterrupt, GeneratorExit):
+            raise
         except BaseException as e:
             additional_error_note = (
                 f"Task: {self.name} ({self.__decl_file}:{self.__decl_line})"
@@ -276,7 +286,60 @@ class BaseTask(AnyTask):
             # Add definition location to the error
             if hasattr(e, "add_note"):
                 e.add_note(additional_error_note)
-            else:
+            elif hasattr(e, "__notes__"):
                 # fallback: use the __notes__ attribute directly
                 e.__notes__ = getattr(e, "__notes__", []) + [additional_error_note]
             raise e
+
+    def to_function(self) -> Callable[..., Any]:
+        from zrb.context.shared_context import SharedContext
+        from zrb.session.session import Session
+
+        def task_runner_fn(**kwargs) -> Any:
+            task_kwargs = self._get_func_kwargs(kwargs)
+            shared_ctx = SharedContext(print_fn=self._print_fn)
+            session = Session(shared_ctx=shared_ctx)
+            return self.run(session=session, kwargs=task_kwargs)
+
+        task_runner_fn.__doc__ = self._create_fn_docstring()
+        task_runner_fn.__signature__ = self._create_fn_signature()
+        task_runner_fn.__name__ = self.name
+        return task_runner_fn
+
+    def _get_func_kwargs(self, kwargs: dict[str, Any]) -> dict[str, Any]:
+        fn_kwargs = {}
+        for inp in self.inputs:
+            snake_input_name = to_snake_case(inp.name)
+            if snake_input_name in kwargs:
+                fn_kwargs[inp.name] = kwargs[snake_input_name]
+        return fn_kwargs
+
+    def _create_fn_docstring(self) -> str:
+        from zrb.context.shared_context import SharedContext
+
+        stub_shared_ctx = SharedContext(print_fn=self._print_fn)
+        str_input_default_values = {}
+        for inp in self.inputs:
+            str_input_default_values[inp.name] = inp.get_default_str(stub_shared_ctx)
+        # Create docstring
+        doc = f"{self.description}\n\n"
+        if len(self.inputs) > 0:
+            doc += "Args:\n"
+            for inp in self.inputs:
+                str_input_default = str_input_default_values.get(inp.name, "")
+                doc += (
+                    f"    {inp.name}: {inp.description} (default: {str_input_default})"
+                )
+                doc += "\n"
+        return doc
+
+    def _create_fn_signature(self) -> inspect.Signature:
+        params = []
+        for inp in self.inputs:
+            params.append(
+                inspect.Parameter(
+                    name=to_snake_case(inp.name),
+                    kind=inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                )
+            )
+        return inspect.Signature(params)