zrb 1.8.10__py3-none-any.whl → 1.21.29__py3-none-any.whl

zrb/session/any_session.py

@@ -1,17 +1,19 @@
 from __future__ import annotations  # Enables forward references
 
+import asyncio
 from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, Any, Coroutine, TypeVar
 
 from zrb.context.any_context import AnyContext
 from zrb.group.any_group import AnyGroup
-from zrb.session_state_log.session_state_log import SessionStateLog
 from zrb.session_state_logger.any_session_state_logger import AnySessionStateLogger
 from zrb.task_status.task_status import TaskStatus
 
 if TYPE_CHECKING:
-    from zrb.context import any_shared_context
-    from zrb.task import any_task
+    from zrb.context.any_shared_context import AnySharedContext
+    from zrb.session_state_log.session_state_log import SessionStateLog
+    from zrb.task.any_task import AnyTask
+
 
 TAnySession = TypeVar("TAnySession", bound="AnySession")
 
@@ -44,7 +46,7 @@ class AnySession(ABC):
 
     @property
     @abstractmethod
-    def shared_ctx(self) -> any_shared_context.AnySharedContext:
+    def shared_ctx(self) -> "AnySharedContext":
         """Shared context for this session"""
         pass
 
@@ -61,12 +63,13 @@ class AnySession(ABC):
 
     @property
     @abstractmethod
-    def parent(self) -> TAnySession | None:
+    def parent(self) -> "AnySession | None":
         """Parent session"""
         pass
 
+    @property
     @abstractmethod
-    def task_path(self) -> str:
+    def task_path(self) -> list[str]:
         """Main task's path"""
         pass
 
@@ -83,16 +86,16 @@ class AnySession(ABC):
         pass
 
     @abstractmethod
-    def set_main_task(self, main_task: any_task.AnyTask):
+    def set_main_task(self, main_task: "AnyTask"):
         """Set main task"""
         pass
 
     @abstractmethod
-    def as_state_log(self) -> SessionStateLog:
+    def as_state_log(self) -> "SessionStateLog":
         pass
 
     @abstractmethod
-    def get_ctx(self, task: any_task.AnyTask) -> AnyContext:
+    def get_ctx(self, task: "AnyTask") -> AnyContext:
         """Retrieves the context for a specific task.
 
         Args:
@@ -104,7 +107,9 @@ class AnySession(ABC):
         pass
 
     @abstractmethod
-    def defer_monitoring(self, task: any_task.AnyTask, coro: Coroutine):
+    def defer_monitoring(
+        self, task: "AnyTask", coro: Coroutine[Any, Any, Any] | asyncio.Task[Any]
+    ):
         """Defers the execution of a task's monitoring coroutine for later processing.
 
         Args:
@@ -114,7 +119,9 @@ class AnySession(ABC):
         pass
 
     @abstractmethod
-    def defer_action(self, task: any_task.AnyTask, coro: Coroutine):
+    def defer_action(
+        self, task: "AnyTask", coro: Coroutine[Any, Any, Any] | asyncio.Task[Any]
+    ):
         """Defers the execution of a task's coroutine for later processing.
 
         Args:
@@ -124,7 +131,7 @@ class AnySession(ABC):
         pass
 
     @abstractmethod
-    def defer_coro(self, coro: Coroutine):
+    def defer_coro(self, coro: Coroutine[Any, Any, Any] | asyncio.Task[Any]):
         """Defers the execution of a coroutine for later processing.
 
         Args:
@@ -138,7 +145,7 @@ class AnySession(ABC):
         pass
 
     @abstractmethod
-    def register_task(self, task: any_task.AnyTask):
+    def register_task(self, task: "AnyTask"):
         """Registers a new task in the session.
 
         Args:
@@ -147,7 +154,7 @@ class AnySession(ABC):
         pass
 
     @abstractmethod
-    def get_root_tasks(self, task: any_task.AnyTask) -> list[any_task.AnyTask]:
+    def get_root_tasks(self, task: "AnyTask") -> list["AnyTask"]:
         """Retrieves the list of root tasks that should be executed first
         to run the given task.
 
@@ -160,7 +167,7 @@ class AnySession(ABC):
         pass
 
     @abstractmethod
-    def get_next_tasks(self, task: any_task.AnyTask) -> list[any_task.AnyTask]:
+    def get_next_tasks(self, task: "AnyTask") -> list["AnyTask"]:
         """Retrieves the list of tasks that should be executed after the given task.
 
         Args:
@@ -172,7 +179,7 @@ class AnySession(ABC):
         pass
 
     @abstractmethod
-    def get_task_status(self, task: any_task.AnyTask) -> TaskStatus:
+    def get_task_status(self, task: "AnyTask") -> TaskStatus:
         """Get tasks' status.
 
         Args:
@@ -184,7 +191,7 @@ class AnySession(ABC):
         pass
 
     @abstractmethod
-    def is_allowed_to_run(self, task: any_task.AnyTask):
+    def is_allowed_to_run(self, task: "AnyTask") -> bool:
         """Determines if the specified task is allowed to run based on its current state.
 
         Args:

zrb/session/session.py

@@ -1,15 +1,12 @@
+from __future__ import annotations
+
 import asyncio
-from typing import Any, Coroutine
+from typing import TYPE_CHECKING, Any, Coroutine
 
 from zrb.context.any_shared_context import AnySharedContext
 from zrb.context.context import AnyContext, Context
 from zrb.group.any_group import AnyGroup
-from zrb.session.any_session import AnySession
-from zrb.session_state_log.session_state_log import (
-    SessionStateLog,
-    TaskStatusHistoryStateLog,
-    TaskStatusStateLog,
-)
+from zrb.session.any_session import AnySession, TAnySession
 from zrb.session_state_logger.any_session_state_logger import AnySessionStateLogger
 from zrb.session_state_logger.session_state_logger_factory import session_state_logger
 from zrb.task.any_task import AnyTask
@@ -32,6 +29,9 @@ from zrb.util.group import get_node_path
 from zrb.util.string.name import get_random_name
 from zrb.xcom.xcom import Xcom
 
+if TYPE_CHECKING:
+    from zrb.session_state_log.session_state_log import SessionStateLog
+
 
 class Session(AnySession):
     def __init__(
@@ -50,10 +50,10 @@ class Session(AnySession):
         self._context: dict[AnyTask, Context] = {}
         self._shared_ctx = shared_ctx
         self._shared_ctx.set_session(self)
-        self._parent = parent
-        self._action_coros: dict[AnyTask, asyncio.Task] = {}
-        self._monitoring_coros: dict[AnyTask, asyncio.Task] = {}
-        self._coros: list[asyncio.Task] = []
+        self._parent: AnySession | None = parent
+        self._action_coros: dict[AnyTask, asyncio.Task[Any]] = {}
+        self._monitoring_coros: dict[AnyTask, asyncio.Task[Any]] = {}
+        self._coros: list[asyncio.Task[Any]] = []
         self._colors = [
             GREEN,
             YELLOW,
@@ -116,11 +116,13 @@ class Session(AnySession):
         return self._parent
 
     @property
-    def task_path(self) -> str:
+    def task_path(self) -> list[str]:
         return self._main_task_path
 
     @property
     def final_result(self) -> Any:
+        if self._main_task is None:
+            return None
         xcom: Xcom = self.shared_ctx.xcom[self._main_task.name]
         try:
             return xcom.peek()
@@ -136,10 +138,20 @@ class Session(AnySession):
     def set_main_task(self, main_task: AnyTask):
         self.register_task(main_task)
         self._main_task = main_task
-        main_task_path = get_node_path(self._root_group, main_task)
+        main_task_path = (
+            None
+            if self._root_group is None
+            else get_node_path(self._root_group, main_task)
+        )
         self._main_task_path = [] if main_task_path is None else main_task_path
 
-    def as_state_log(self) -> SessionStateLog:
+    def as_state_log(self) -> "SessionStateLog":
+        from zrb.session_state_log.session_state_log import (
+            SessionStateLog,
+            TaskStatusHistoryStateLog,
+            TaskStatusStateLog,
+        )
+
         task_status_log: dict[str, TaskStatusStateLog] = {}
         log_start_time = ""
         for task, task_status in self._task_status.items():
@@ -167,7 +179,7 @@ class Session(AnySession):
         return SessionStateLog(
             name=self.name,
             start_time=log_start_time,
-            main_task_name=self._main_task.name,
+            main_task_name="" if self._main_task is None else self._main_task.name,
             path=self.task_path,
             final_result=(
                 remove_style(f"{self.final_result}")
@@ -184,16 +196,29 @@ class Session(AnySession):
         self._register_single_task(task)
         return self._context[task]
 
-    def defer_monitoring(self, task: AnyTask, coro: Coroutine):
+    def defer_monitoring(
+        self, task: AnyTask, coro: Coroutine[Any, Any, Any] | asyncio.Task[Any]
+    ):
         self._register_single_task(task)
-        self._monitoring_coros[task] = coro
+        if isinstance(coro, asyncio.Task):
+            self._monitoring_coros[task] = coro
+        else:
+            self._monitoring_coros[task] = asyncio.create_task(coro)
 
-    def defer_action(self, task: AnyTask, coro: Coroutine):
+    def defer_action(
+        self, task: AnyTask, coro: Coroutine[Any, Any, Any] | asyncio.Task[Any]
+    ):
         self._register_single_task(task)
-        self._action_coros[task] = coro
+        if isinstance(coro, asyncio.Task):
+            self._action_coros[task] = coro
+        else:
+            self._action_coros[task] = asyncio.create_task(coro)
 
-    def defer_coro(self, coro: Coroutine):
-        self._coros.append(coro)
+    def defer_coro(self, coro: Coroutine[Any, Any, Any] | asyncio.Task[Any]):
+        if isinstance(coro, asyncio.Task):
+            self._coros.append(coro)
+        else:
+            self._coros.append(asyncio.create_task(coro))
         self._coros = [
             existing_coro for existing_coro in self._coros if not existing_coro.done()
         ]
@@ -242,15 +267,15 @@ class Session(AnySession):
 
     def get_next_tasks(self, task: AnyTask) -> list[AnyTask]:
         self._register_single_task(task)
-        return self._downstreams.get(task)
+        return self._downstreams.get(task, [])
 
     def get_task_status(self, task: AnyTask) -> TaskStatus:
         self._register_single_task(task)
         return self._task_status[task]
 
     def _register_single_task(self, task: AnyTask):
-        if task.name not in self._shared_ctx._xcom:
-            self._shared_ctx._xcom[task.name] = Xcom([])
+        if task.name not in self._shared_ctx.xcom:
+            self._shared_ctx.xcom[task.name] = Xcom([])
         if task not in self._context:
             self._context[task] = Context(
                 shared_ctx=self._shared_ctx,
@@ -274,7 +299,7 @@ class Session(AnySession):
             self._color_index = 0
         return chosen
 
-    def _get_icon(self, task: AnyTask) -> int:
+    def _get_icon(self, task: AnyTask) -> str:
         if task.icon is not None:
             return task.icon
         chosen = self._icons[self._icon_index]

zrb/session_state_logger/any_session_state_logger.py

@@ -1,16 +1,21 @@
 import datetime
 from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
 
-from zrb.session_state_log.session_state_log import SessionStateLog, SessionStateLogList
+if TYPE_CHECKING:
+    from zrb.session_state_log.session_state_log import (
+        SessionStateLog,
+        SessionStateLogList,
+    )
 
 
 class AnySessionStateLogger(ABC):
     @abstractmethod
-    def write(self, session_log: SessionStateLog):
+    def write(self, session_log: "SessionStateLog"):
         pass
 
     @abstractmethod
-    def read(self, session_name: str) -> SessionStateLog:
+    def read(self, session_name: str) -> "SessionStateLog":
         pass
 
     @abstractmethod
@@ -21,5 +26,5 @@ class AnySessionStateLogger(ABC):
         max_start_time: datetime.datetime,
         page: int = 0,
         limit: int = 10,
-    ) -> SessionStateLogList:
+    ) -> "SessionStateLogList":
         pass

zrb/session_state_logger/file_session_state_logger.py

@@ -1,16 +1,22 @@
 import datetime
 import os
+from typing import TYPE_CHECKING
 
-from zrb.session_state_log.session_state_log import SessionStateLog, SessionStateLogList
 from zrb.session_state_logger.any_session_state_logger import AnySessionStateLogger
 from zrb.util.file import read_file, write_file
 
+if TYPE_CHECKING:
+    from zrb.session_state_log.session_state_log import (
+        SessionStateLog,
+        SessionStateLogList,
+    )
+
 
 class FileSessionStateLogger(AnySessionStateLogger):
     def __init__(self, session_log_dir: str):
         self._session_log_dir = session_log_dir
 
-    def write(self, session_log: SessionStateLog):
+    def write(self, session_log: "SessionStateLog"):
         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):
@@ -22,7 +28,9 @@ class FileSessionStateLogger(AnySessionStateLogger):
         timeline_dir_path = self._get_timeline_dir_path(session_log)
         write_file(os.path.join(timeline_dir_path, session_log.name), "")
 
-    def read(self, session_name: str) -> SessionStateLog:
+    def read(self, session_name: str) -> "SessionStateLog":
+        from zrb.session_state_log.session_state_log import SessionStateLog
+
         session_file_path = self._get_session_file_path(session_name)
         return SessionStateLog.model_validate_json(read_file(session_file_path))
 
@@ -33,7 +41,9 @@ class FileSessionStateLogger(AnySessionStateLogger):
         max_start_time: datetime.datetime,
         page: int = 0,
         limit: int = 10,
-    ) -> SessionStateLogList:
+    ) -> "SessionStateLogList":
+        from zrb.session_state_log.session_state_log import SessionStateLogList
+
         matching_sessions = []
         # Traverse the timeline directory and filter sessions
         timeline_dir = os.path.join(self._session_log_dir, "_timeline", *task_path)
@@ -62,7 +72,7 @@ class FileSessionStateLogger(AnySessionStateLogger):
     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) -> 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
@@ -80,7 +90,7 @@ class FileSessionStateLogger(AnySessionStateLogger):
         ]
         return os.path.join(self._session_log_dir, "_timeline", *paths)
 
-    def _get_start_time(self, session_log: SessionStateLog) -> datetime.datetime:
+    def _get_start_time(self, session_log: "SessionStateLog") -> datetime.datetime:
         return datetime.datetime.strptime(
             session_log.start_time, "%Y-%m-%d %H:%M:%S.%f"
         )

zrb/session_state_logger/session_state_logger_factory.py

@@ -1,4 +1,4 @@
-from zrb.config import CFG
+from zrb.config.config import CFG
 from zrb.session_state_logger.file_session_state_logger import FileSessionStateLogger
 
 session_state_logger = FileSessionStateLogger(CFG.SESSION_LOG_DIR)

zrb/task/any_task.py

@@ -1,14 +1,14 @@
 from __future__ import annotations  # Enables forward references
 
 from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Callable
 
 from zrb.env.any_env import AnyEnv
 from zrb.input.any_input import AnyInput
 
 if TYPE_CHECKING:
-    from zrb.context import any_context
-    from zrb.session import session
+    from zrb.context.any_context import AnyContext
+    from zrb.session.any_session import AnySession
 
 
 class AnyTask(ABC):
@@ -36,6 +36,14 @@ class AnyTask(ABC):
     the actual implementation for these abstract members.
     """
 
+    @abstractmethod
+    def __rshift__(self, other: "AnyTask | list[AnyTask]") -> "AnyTask | list[AnyTask]":
+        pass
+
+    @abstractmethod
+    def __lshift__(self, other: "AnyTask | list[AnyTask]") -> "AnyTask":
+        pass
+
     @property
     @abstractmethod
     def name(self) -> str:
@@ -143,18 +151,22 @@ class AnyTask(ABC):
         pass
 
     @abstractmethod
-    def get_ctx(self, session: session.AnySession) -> any_context.AnyContext:
+    def get_ctx(self, session: "AnySession") -> "AnyContext":
         pass
 
     @abstractmethod
     def run(
-        self, session: 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:
         """Runs the task synchronously.
 
         Args:
             session (AnySession): The shared session.
             str_kwargs(dict[str, str]): The input string values.
+            kwargs(dict[str, Any]): The input values.
 
         Returns:
             Any: The result of the task execution.
@@ -163,13 +175,17 @@ class AnyTask(ABC):
 
     @abstractmethod
     async def async_run(
-        self, session: 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:
         """Runs the task asynchronously.
 
         Args:
             session (AnySession): The shared session.
             str_kwargs(dict[str, str]): The input string values.
+            kwargs(dict[str, Any]): The input values.
 
         Returns:
             Any: The result of the task execution.
@@ -177,7 +193,7 @@ class AnyTask(ABC):
         pass
 
     @abstractmethod
-    async def exec_root_tasks(self, session: session.AnySession):
+    async def exec_root_tasks(self, session: "AnySession"):
         """Execute the root tasks along with the downstreams until the current task
         is ready.
 
@@ -187,7 +203,7 @@ class AnyTask(ABC):
         pass
 
     @abstractmethod
-    async def exec_chain(self, session: session.AnySession):
+    async def exec_chain(self, session: "AnySession"):
         """Execute the task along with the downstreams.
 
         Args:
@@ -196,10 +212,15 @@ class AnyTask(ABC):
         pass
 
     @abstractmethod
-    async def exec(self, session: session.AnySession):
+    async def exec(self, session: "AnySession"):
         """Execute the task (without upstream or downstream).
 
         Args:
             session (AnySession): The shared session.
         """
         pass
+
+    @abstractmethod
+    def to_function(self) -> Callable[..., Any]:
+        """Turn a task into a function"""
+        pass

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(

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")
@@ -140,8 +146,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,8 +169,9 @@ 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)
@@ -201,7 +208,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

@@ -12,7 +12,8 @@ from zrb.util.run import run_async
 async def run_and_cleanup(
     task: AnyTask,
     session: AnySession | None = None,
-    str_kwargs: dict[str, str] = {},
+    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
@@ -23,7 +24,9 @@ async def run_and_cleanup(
         session = Session(shared_ctx=SharedContext())
 
     # 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, str_kwargs, kwargs)
+    )
 
     try:
         result = await main_task_coro
@@ -67,7 +70,8 @@ async def run_and_cleanup(
 async def run_task_async(
     task: AnyTask,
     session: AnySession | None = None,
-    str_kwargs: dict[str, str] = {},
+    str_kwargs: dict[str, str] | None = None,
+    kwargs: dict[str, Any] | None = None,
 ) -> Any:
     """
     Asynchronous entry point for running a task (`task.async_run()`).
@@ -77,7 +81,7 @@ async def run_task_async(
         session = Session(shared_ctx=SharedContext())
 
     # 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