griptape-nodes 0.66.2__py3-none-any.whl → 0.68.0__py3-none-any.whl

griptape_nodes/bootstrap/utils/python_subprocess_executor.py

@@ -2,16 +2,24 @@ from __future__ import annotations
 
 import asyncio
 import logging
+import os
 import sys
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     from pathlib import Path
-    from subprocess import _ENV
 
 logger = logging.getLogger(__name__)
 
 
+def _create_subprocess_env(extra_env: dict[str, str] | None = None) -> dict[str, str]:
+    """Create environment for subprocess, inheriting parent env with optional overrides."""
+    env = os.environ.copy()
+    if extra_env:
+        env.update(extra_env)
+    return env
+
+
 class PythonSubprocessExecutorError(Exception):
     """Exception raised during Python subprocess execution."""
 
@@ -22,7 +30,11 @@ class PythonSubprocessExecutor:
         self._is_running = False
 
     async def execute_python_script(
-        self, script_path: Path, args: list[str] | None = None, cwd: Path | None = None, env: _ENV | None = None
+        self,
+        script_path: Path,
+        args: list[str] | None = None,
+        cwd: Path | None = None,
+        env: dict[str, str] | None = None,
     ) -> None:
         """Execute a Python script in a subprocess and wait for completion.
 
@@ -30,7 +42,7 @@ class PythonSubprocessExecutor:
             script_path: Path to the Python script to execute
             args: Additional command line arguments
             cwd: Working directory for the subprocess
-            env: Environment variables for the subprocess
+            env: Extra environment variables to add or override in the subprocess
         """
         if self.is_running():
             logger.warning("Another subprocess is already running. Terminating it first.")
@@ -38,6 +50,7 @@ class PythonSubprocessExecutor:
 
         args = args or []
         command = [sys.executable, str(script_path), *args]
+        subprocess_env = _create_subprocess_env(env)
 
         try:
             logger.info("Starting subprocess: %s", " ".join(command))
@@ -46,7 +59,7 @@ class PythonSubprocessExecutor:
             self._process = await asyncio.create_subprocess_exec(
                 *command,
                 cwd=cwd,
-                env=env,
+                env=subprocess_env,
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.PIPE,
             )

griptape_nodes/common/node_executor.py

@@ -5,6 +5,7 @@ import asyncio
 import logging
 import pickle
 from dataclasses import dataclass
+from enum import StrEnum
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, NamedTuple
 
@@ -16,7 +17,7 @@ from griptape_nodes.exe_types.base_iterative_nodes import (
     BaseIterativeStartNode,
 )
 from griptape_nodes.exe_types.core_types import ParameterTypeBuiltin
-from griptape_nodes.exe_types.node_groups import BaseIterativeNodeGroup, SubflowNodeGroup
+from griptape_nodes.exe_types.node_groups import BaseIterativeNodeGroup, IterationControlParam, SubflowNodeGroup
 from griptape_nodes.exe_types.node_types import (
     CONTROL_INPUT_PARAMETER,
     LOCAL_EXECUTION,
@@ -106,6 +107,15 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger("griptape_nodes")
 
+
+class IterationControlAction(StrEnum):
+    """Enum for iterative group control actions."""
+
+    ADD = "add"  # Normal path - add result to list
+    SKIP = "skip"  # Skip this iteration, don't add result
+    BREAK = "break"  # Break out of loop immediately
+
+
 LOOP_EVENTS_TO_SUPPRESS = {
     CreateFlowResultSuccess,
     CreateFlowResultFailure,
@@ -816,13 +826,153 @@ class NodeExecutor:
         # Check if it's the break signal
         return next_control_output == deserialized_end_node.break_loop_signal_output
 
-    async def _execute_loop_iterations_sequentially(  # noqa: PLR0915
+    def _get_iteration_control_action_for_group(
+        self,
+        end_loop_node: BaseIterativeNodeGroup,
+        node_name_mappings: dict[str, str],
+    ) -> IterationControlAction:
+        """Determine which control action was taken during iteration for an iterative group.
+
+        Checks if any internal nodes have executed their control outputs that connect to the
+        group's control parameters (loop_complete, skip_iteration, break_loop). This is done by
+        checking the source node's parameter_output_values for CONTROL_INPUT_PARAMETER.
+
+        Args:
+            end_loop_node: The BaseIterativeNodeGroup being executed
+            node_name_mappings: Mapping from original to deserialized node names
+
+        Returns:
+            IterationControlAction indicating which control path was taken
+        """
+        # Get incoming connections to the end_loop_node (the iterative group)
+        list_connections_request = ListConnectionsForNodeRequest(node_name=end_loop_node.name)
+        list_connections_result = GriptapeNodes.handle_request(list_connections_request)
+        if not isinstance(list_connections_result, ListConnectionsForNodeResultSuccess):
+            logger.warning("Failed to list connections for node %s", end_loop_node.name)
+            return IterationControlAction.ADD
+
+        incoming_connections = list_connections_result.incoming_connections
+
+        # Check each control parameter to see if its source node has fired
+        # Priority: BREAK > SKIP > LOOP_COMPLETE > default ADD
+        break_source = self._find_source_for_control_param(incoming_connections, IterationControlParam.BREAK_LOOP)
+        skip_source = self._find_source_for_control_param(incoming_connections, IterationControlParam.SKIP_ITERATION)
+        loop_complete_source = self._find_source_for_control_param(
+            incoming_connections, IterationControlParam.LOOP_COMPLETE
+        )
+
+        # Check if break was triggered
+        if self._check_control_source_fired(break_source, node_name_mappings):
+            return IterationControlAction.BREAK
+
+        # Check if skip was triggered
+        if self._check_control_source_fired(skip_source, node_name_mappings):
+            return IterationControlAction.SKIP
+
+        # Check if loop_complete was triggered
+        if self._check_control_source_fired(loop_complete_source, node_name_mappings):
+            return IterationControlAction.ADD
+
+        # If none of the control parameters were triggered, default to ADD
+        # This preserves backward compatibility for workflows without explicit loop_complete connections
+        return IterationControlAction.ADD
+
+    def _check_control_source_fired(
+        self,
+        source: tuple[str, str] | None,
+        node_name_mappings: dict[str, str],
+    ) -> bool:
+        """Check if a control source node has fired its control output.
+
+        Args:
+            source: Tuple of (source_node_name, source_parameter_name) or None
+            node_name_mappings: Mapping from original to deserialized node names
+
+        Returns:
+            True if the source node's next control output matches the specified parameter
+        """
+        if source is None:
+            return False
+
+        source_node_name, source_param_name = source
+        deserialized_source_name = node_name_mappings.get(source_node_name)
+        if deserialized_source_name is None:
+            return False
+
+        node_manager = GriptapeNodes.NodeManager()
+        try:
+            deserialized_source_node = node_manager.get_node_by_name(deserialized_source_name)
+        except ValueError:
+            return False
+
+        if deserialized_source_node is None:
+            return False
+
+        # Check if the node's next control output matches the source parameter
+        next_control_output = deserialized_source_node.get_next_control_output()
+        if next_control_output is None:
+            return False
+
+        # Get the parameter object to compare
+        source_param = deserialized_source_node.get_parameter_by_name(source_param_name)
+        return next_control_output == source_param
+
+    def _find_source_for_control_param(
+        self,
+        incoming_connections: list,
+        control_param_name: str,
+    ) -> tuple[str, str] | None:
+        """Find the source node and parameter that connects to a control parameter on the iterative group.
+
+        Args:
+            incoming_connections: List of incoming connections to the iterative group
+            control_param_name: Name of the control parameter to find (e.g., "break_loop")
+
+        Returns:
+            Tuple of (source_node_name, source_parameter_name), or None if not found
+        """
+        flow_manager = GriptapeNodes.FlowManager()
+        connections = flow_manager.get_connections()
+
+        for conn in incoming_connections:
+            if conn.target_parameter_name != control_param_name:
+                continue
+
+            source_node_name = conn.source_node_name
+            source_param_name = conn.source_parameter_name
+
+            # If source is a SubflowNodeGroup, follow the internal connection to get the actual source
+            node_manager = GriptapeNodes.NodeManager()
+            try:
+                source_node = node_manager.get_node_by_name(source_node_name)
+            except ValueError:
+                continue
+
+            if isinstance(source_node, SubflowNodeGroup):
+                # Get connections to this proxy parameter to find the actual internal source
+                proxy_param = source_node.get_parameter_by_name(source_param_name)
+                if proxy_param:
+                    internal_connections = connections.get_all_incoming_connections(source_node)
+                    for internal_conn in internal_connections:
+                        if (
+                            internal_conn.target_parameter.name == source_param_name
+                            and internal_conn.is_node_group_internal
+                        ):
+                            source_node_name = internal_conn.source_node.name
+                            source_param_name = internal_conn.source_parameter.name
+                            break
+
+            return (source_node_name, source_param_name)
+
+        return None
+
+    async def _execute_loop_iterations_sequentially(  # noqa: PLR0915, C901, PLR0912
         self,
         package_result: PackageNodesAsSerializedFlowResultSuccess,
         total_iterations: int,
         parameter_values_per_iteration: dict[int, dict[str, Any]],
         end_loop_node: BaseIterativeEndNode | BaseIterativeNodeGroup,
-    ) -> tuple[dict[int, Any], list[int], dict[str, Any]]:
+    ) -> tuple[dict[int, Any], list[int], dict[str, Any], int, bool]:
         """Execute loop iterations sequentially by running one flow instance N times.
 
         Args:
@@ -834,8 +984,10 @@ class NodeExecutor:
         Returns:
             Tuple of:
             - iteration_results: Dict mapping iteration_index -> result value
-            - successful_iterations: List of iteration indices that succeeded
+            - successful_iterations: List of iteration indices that executed without error
             - last_iteration_values: Dict mapping parameter names -> values from last iteration
+            - skipped_count: Number of iterations that were skipped via skip control signal
+            - break_occurred: True if the loop exited early due to a break signal
         """
         # Deserialize flow once
         context_manager = GriptapeNodes.ContextManager()
@@ -868,6 +1020,8 @@ class NodeExecutor:
 
         iteration_results: dict[int, Any] = {}
         successful_iterations: list[int] = []
+        skipped_count = 0
+        break_occurred = False
 
         # Build reverse mapping: packaged_name → original_name for event translation
         reverse_node_mapping = {
@@ -927,6 +1081,39 @@ class NodeExecutor:
 
                 successful_iterations.append(iteration_index)
 
+                # For BaseIterativeNodeGroup, check control action to handle skip/break
+                if isinstance(end_loop_node, BaseIterativeNodeGroup):
+                    control_action = self._get_iteration_control_action_for_group(end_loop_node, node_name_mappings)
+
+                    if control_action == IterationControlAction.SKIP:
+                        logger.info(
+                            "Skip detected at iteration %d/%d - skipping result collection",
+                            iteration_index + 1,
+                            total_iterations,
+                        )
+                        skipped_count += 1
+                        continue
+
+                    if control_action == IterationControlAction.BREAK:
+                        logger.info(
+                            "Break detected at iteration %d/%d - collecting result then stopping",
+                            iteration_index + 1,
+                            total_iterations,
+                        )
+                        # Extract result from this iteration before breaking
+                        # (the work was done, so we should collect the result)
+                        deserialized_flows = [(iteration_index, flow_name, node_name_mappings)]
+                        single_iteration_results = self.get_parameter_values_from_iterations(
+                            end_loop_node=end_loop_node,
+                            deserialized_flows=deserialized_flows,
+                            package_flow_result_success=package_result,
+                        )
+                        iteration_results.update(single_iteration_results)
+                        break_occurred = True
+                        break
+
+                    # control_action == ADD: fall through to extract result
+
                 # Extract result from this iteration
                 deserialized_flows = [(iteration_index, flow_name, node_name_mappings)]
                 single_iteration_results = self.get_parameter_values_from_iterations(
@@ -938,13 +1125,14 @@ class NodeExecutor:
 
                 logger.info("Completed sequential iteration %d/%d", iteration_index + 1, total_iterations)
 
-                # Check if the end node signaled a break
+                # Check if the end node signaled a break (for BaseIterativeEndNode)
                 if self._should_break_loop(node_name_mappings, package_result):
                     logger.info(
                         "Loop break detected at iteration %d/%d - stopping execution early",
                         iteration_index + 1,
                         total_iterations,
                     )
+                    break_occurred = True
                     break
 
             # Extract last iteration values from the last successful iteration
@@ -956,7 +1144,7 @@ class NodeExecutor:
                 total_iterations=len(successful_iterations),
             )
 
-            return iteration_results, successful_iterations, last_iteration_values
+            return iteration_results, successful_iterations, last_iteration_values, skipped_count, break_occurred
 
         finally:
             # Cleanup - delete the flow
@@ -1018,6 +1206,8 @@ class NodeExecutor:
                 iteration_results,
                 successful_iterations,
                 last_iteration_values,
+                _skipped_count,
+                _break_occurred,
             ) = await self._execute_loop_iterations_sequentially(
                 package_result=package_result,
                 total_iterations=total_iterations,
@@ -1383,12 +1573,16 @@ class NodeExecutor:
         parameter_values_per_iteration = self._get_merged_parameter_values_for_iterative_group(node, package_result)
 
         # Execute iterations sequentially based on execution environment
+        skipped_count = 0
+        break_occurred = False
         match execution_type:
             case node_types.LOCAL_EXECUTION:
                 (
                     iteration_results,
                     successful_iterations,
                     last_iteration_values,
+                    skipped_count,
+                    break_occurred,
                 ) = await self._execute_loop_iterations_sequentially(
                     package_result=package_result,
                     total_iterations=total_iterations,
@@ -1420,19 +1614,25 @@ class NodeExecutor:
                     execution_type=execution_type,
                 )
 
-        # Check if execution stopped early due to break (not failure)
+        # Check if execution stopped early
         if len(successful_iterations) < total_iterations:
-            expected_count = len(successful_iterations)
-            actual_count = len(iteration_results)
-            if expected_count != actual_count:
-                failed_count = expected_count - actual_count
-                msg = f"Iterative group execution failed: {failed_count} of {expected_count} iterations failed"
-                raise RuntimeError(msg)
-            logger.info(
-                "Iterative group execution stopped early at %d of %d iterations (break signal)",
-                len(successful_iterations),
-                total_iterations,
-            )
+            if break_occurred:
+                # Early exit due to break signal - this is expected behavior
+                logger.info(
+                    "Iterative group execution stopped early at %d of %d iterations (break signal)",
+                    len(successful_iterations),
+                    total_iterations,
+                )
+            else:
+                # Early exit not due to break - check for failures
+                # successful_iterations includes skipped iterations, but iteration_results does not
+                # So we need to account for skipped iterations when checking for failures
+                expected_result_count = len(successful_iterations) - skipped_count
+                actual_result_count = len(iteration_results)
+                if expected_result_count != actual_result_count:
+                    failed_count = expected_result_count - actual_result_count
+                    msg = f"Iterative group execution failed: {failed_count} of {len(successful_iterations)} iterations failed"
+                    raise RuntimeError(msg)
 
         # Build results list in iteration order
         node._results_list = []
@@ -1772,6 +1972,12 @@ class NodeExecutor:
         Returns:
             The upstream value if criteria met, None otherwise
         """
+        # If upstream is a BaseIterativeNodeGroup (e.g., ForEach Group) that's currently executing,
+        # we need to trace through its proxy parameter to find the actual resolved source.
+        # This handles the case where: ExternalNode -> ForEachGroup.proxy_param -> InternalNode
+        if isinstance(upstream_node, BaseIterativeNodeGroup) and upstream_node.state != NodeResolutionState.RESOLVED:
+            return self._get_value_through_iterative_group_proxy(upstream_node, upstream_param, packaged_node_names)
+
         if upstream_node.state != NodeResolutionState.RESOLVED:
             return None
 
@@ -1783,6 +1989,77 @@ class NodeExecutor:
 
         return upstream_node.get_parameter_value(upstream_param.name)
 
+    def _get_value_through_iterative_group_proxy(
+        self,
+        iterative_group: BaseIterativeNodeGroup,
+        proxy_param: Any,
+        packaged_node_names: list[str],
+    ) -> Any | None:
+        """Trace through an iterative group's proxy parameter to get value from the actual resolved source.
+
+        When a packaged node inside a ForEach Group has an incoming connection from the group's
+        proxy parameter, we need to find the external node that connects TO that proxy parameter
+        and get the value from there.
+
+        Connection chain: ResolvedExternalNode -> IterativeGroup.proxy_param -> PackagedInternalNode
+        We want to get the value from ResolvedExternalNode.
+
+        Args:
+            iterative_group: The BaseIterativeNodeGroup with the proxy parameter
+            proxy_param: The proxy parameter on the iterative group
+            packaged_node_names: List of packaged node names to exclude
+
+        Returns:
+            The value from the resolved external source, or None if not found
+        """
+        flow_manager = GriptapeNodes.FlowManager()
+        connections = flow_manager.get_connections()
+
+        # Find the incoming connection TO the proxy parameter on the iterative group
+        # This will give us the actual external source node
+        incoming_to_proxy = connections.get_incoming_connections_to_parameter(iterative_group, proxy_param)
+
+        for conn in incoming_to_proxy:
+            # Skip internal connections (from nodes inside the group)
+            if conn.is_node_group_internal:
+                continue
+
+            source_node = conn.source_node
+            source_param = conn.source_parameter
+
+            # Skip if the source is also inside the packaged nodes
+            if source_node.name in packaged_node_names:
+                continue
+
+            # The source must be resolved for us to get its value
+            if source_node.state != NodeResolutionState.RESOLVED:
+                logger.debug(
+                    "Source node '%s' for proxy param '%s.%s' is not resolved (state: %s)",
+                    source_node.name,
+                    iterative_group.name,
+                    proxy_param.name,
+                    source_node.state,
+                )
+                continue
+
+            # Get the value from the resolved source node
+            if source_param.name in source_node.parameter_output_values:
+                value = source_node.parameter_output_values[source_param.name]
+            else:
+                value = source_node.get_parameter_value(source_param.name)
+
+            logger.debug(
+                "Traced through proxy: %s.%s -> %s.%s (value type: %s)",
+                source_node.name,
+                source_param.name,
+                iterative_group.name,
+                proxy_param.name,
+                type(value).__name__ if value is not None else "None",
+            )
+            return value
+
+        return None
+
     def _map_to_startflow_parameter(
         self,
         packaged_node_name: str,

griptape_nodes/exe_types/core_types.py

@@ -908,7 +908,15 @@ class DeprecationMessage(ParameterMessage):
 class ParameterGroup(BaseNodeElement, UIOptionsMixin):
     """UI element for a group of parameters."""
 
-    def __init__(self, name: str, ui_options: dict | None = None, *, collapsed: bool = False, **kwargs):
+    def __init__(
+        self,
+        name: str,
+        ui_options: dict | None = None,
+        *,
+        collapsed: bool = False,
+        user_defined: bool = False,
+        **kwargs,
+    ):
         super().__init__(name=name, **kwargs)
         if ui_options is None:
             ui_options = {}
@@ -920,6 +928,7 @@ class ParameterGroup(BaseNodeElement, UIOptionsMixin):
             ui_options["collapsed"] = collapsed
 
         self._ui_options = ui_options
+        self.user_defined = user_defined
 
     @property
     def ui_options(self) -> dict:
@@ -1181,6 +1190,7 @@ class Parameter(BaseNodeElement, UIOptionsMixin):
     serializable: bool = True
 
     user_defined: bool = False
+    private: bool = False
     _allowed_modes: set = field(
         default_factory=lambda: {
             ParameterMode.OUTPUT,
@@ -1222,6 +1232,7 @@ class Parameter(BaseNodeElement, UIOptionsMixin):
         settable: bool = True,
         serializable: bool = True,
         user_defined: bool = False,
+        private: bool = False,
         element_id: str | None = None,
         element_type: str | None = None,
         parent_container_name: str | None = None,
@@ -1246,6 +1257,7 @@ class Parameter(BaseNodeElement, UIOptionsMixin):
         self._settable = settable
         self.serializable = serializable
         self.user_defined = user_defined
+        self.private = private
 
         # Process allowed_modes - use convenience parameters if allowed_modes not explicitly set
         if allowed_modes is None:
@@ -1401,6 +1413,7 @@ class Parameter(BaseNodeElement, UIOptionsMixin):
         our_dict["is_user_defined"] = self.user_defined
         our_dict["settable"] = self.settable
         our_dict["serializable"] = self.serializable
+        our_dict["private"] = self.private
         our_dict["ui_options"] = self.ui_options
 
         # Let's bundle up the mode details.
@@ -1838,6 +1851,7 @@ class ControlParameter(Parameter, ABC):
         ui_options: dict | None = None,
         *,
         user_defined: bool = False,
+        private: bool = False,
     ):
         # Call parent with a few explicit tweaks.
         super().__init__(
@@ -1857,6 +1871,7 @@ class ControlParameter(Parameter, ABC):
             validators=validators,
             ui_options=ui_options,
             user_defined=user_defined,
+            private=private,
             element_type=self.__class__.__name__,
         )
 
@@ -1875,6 +1890,7 @@ class ControlParameterInput(ControlParameter):
         validators: list[Callable[[Parameter, Any], None]] | None = None,
         *,
         user_defined: bool = False,
+        private: bool = False,
     ):
         allowed_modes = {ParameterMode.INPUT}
         input_types = [ParameterTypeBuiltin.CONTROL_TYPE.value]
@@ -1899,6 +1915,7 @@ class ControlParameterInput(ControlParameter):
             validators=validators,
             ui_options=ui_options,
             user_defined=user_defined,
+            private=private,
         )
 
 
@@ -1916,6 +1933,7 @@ class ControlParameterOutput(ControlParameter):
         validators: list[Callable[[Parameter, Any], None]] | None = None,
         *,
         user_defined: bool = False,
+        private: bool = False,
     ):
         allowed_modes = {ParameterMode.OUTPUT}
         output_type = ParameterTypeBuiltin.CONTROL_TYPE.value
@@ -1940,6 +1958,7 @@ class ControlParameterOutput(ControlParameter):
             validators=validators,
             ui_options=ui_options,
             user_defined=user_defined,
+            private=private,
         )
 
 
@@ -1970,6 +1989,7 @@ class ParameterContainer(Parameter, ABC):
         hide: bool | None = None,
         settable: bool = True,
         user_defined: bool = False,
+        private: bool = False,
         element_id: str | None = None,
         element_type: str | None = None,
     ):
@@ -1991,6 +2011,7 @@ class ParameterContainer(Parameter, ABC):
             hide=hide,
             settable=settable,
             user_defined=user_defined,
+            private=private,
             element_id=element_id,
             element_type=element_type,
         )
@@ -2040,6 +2061,7 @@ class ParameterList(ParameterContainer):
         hide: bool | None = None,
         settable: bool = True,
         user_defined: bool = False,
+        private: bool = False,
         element_id: str | None = None,
         element_type: str | None = None,
         max_items: int | None = None,
@@ -2080,6 +2102,7 @@ class ParameterList(ParameterContainer):
             hide=hide,
             settable=settable,
             user_defined=user_defined,
+            private=private,
             element_id=element_id,
             element_type=element_type,
         )
@@ -2418,6 +2441,7 @@ class ParameterKeyValuePair(Parameter):
         *,
         settable: bool = True,
         user_defined: bool = False,
+        private: bool = False,
         element_id: str | None = None,
         element_type: str | None = None,
     ):
@@ -2437,6 +2461,7 @@ class ParameterKeyValuePair(Parameter):
             validators=validators,
             settable=settable,
             user_defined=user_defined,
+            private=private,
             element_id=element_id,
             element_type=element_type,
         )
@@ -2538,6 +2563,7 @@ class ParameterDictionary(ParameterContainer):
         *,
         settable: bool = True,
         user_defined: bool = False,
+        private: bool = False,
         element_id: str | None = None,
         element_type: str | None = None,
     ):
@@ -2557,6 +2583,7 @@ class ParameterDictionary(ParameterContainer):
             validators=validators,
             settable=settable,
             user_defined=user_defined,
+            private=private,
             element_id=element_id,
             element_type=element_type,
         )

griptape_nodes/exe_types/node_groups/__init__.py

@@ -1,7 +1,7 @@
 """Node group implementations for managing collections of nodes."""
 
-from .base_iterative_node_group import BaseIterativeNodeGroup
+from .base_iterative_node_group import BaseIterativeNodeGroup, IterationControlParam
 from .base_node_group import BaseNodeGroup
 from .subflow_node_group import SubflowNodeGroup
 
-__all__ = ["BaseIterativeNodeGroup", "BaseNodeGroup", "SubflowNodeGroup"]
+__all__ = ["BaseIterativeNodeGroup", "BaseNodeGroup", "IterationControlParam", "SubflowNodeGroup"]