Codex
406 lines
15 KiB
Python
406 lines
15 KiB
Python
"""
|
||
循环节点
|
||
|
||
支持两种循环模式：
|
||
1. for_each - 遍历数组，对每个元素执行循环体
|
||
2. while - 条件循环，满足条件时持续执行
|
||
"""
|
||
import ast
|
||
import json
|
||
import logging
|
||
import operator
|
||
from typing import Any, Dict, List
|
||
|
||
from ..base import BaseNode, NodeContext, NodeResult
|
||
from ..registry import NodeRegistry
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
|
||
@NodeRegistry.register
|
||
class LoopNode(BaseNode):
|
||
"""
|
||
循环节点
|
||
|
||
支持 for_each 和 while 两种循环模式
|
||
"""
|
||
|
||
node_type = 'loop'
|
||
node_name = '循环'
|
||
node_category = 'logic'
|
||
node_icon = 'repeat'
|
||
node_description = '循环执行一组节点，支持遍历数组或条件循环'
|
||
|
||
supports_branches = True
|
||
|
||
inputs = [
|
||
{
|
||
'name': 'items',
|
||
'type': 'array',
|
||
'description': '要遍历的数组（for_each 模式）',
|
||
},
|
||
]
|
||
|
||
outputs = [
|
||
{
|
||
'name': 'results',
|
||
'type': 'array',
|
||
'description': '每次循环的结果数组',
|
||
},
|
||
{
|
||
'name': 'current_item',
|
||
'type': 'any',
|
||
'description': '当前循环项（循环体内可用）',
|
||
},
|
||
{
|
||
'name': 'current_index',
|
||
'type': 'number',
|
||
'description': '当前循环索引（从 0 开始）',
|
||
},
|
||
]
|
||
|
||
# 支持的操作符（用于 while 条件判断）
|
||
OPERATORS = {
|
||
'eq': operator.eq, # 等于
|
||
'ne': operator.ne, # 不等于
|
||
'gt': operator.gt, # 大于
|
||
'gte': operator.ge, # 大于等于
|
||
'lt': operator.lt, # 小于
|
||
'lte': operator.le, # 小于等于
|
||
'is_empty': lambda a, _: not a, # 为空
|
||
'is_not_empty': lambda a, _: bool(a), # 不为空
|
||
'is_true': lambda a, _: bool(a), # 为真
|
||
'is_false': lambda a, _: not bool(a), # 为假
|
||
}
|
||
|
||
def execute(self, context: NodeContext) -> NodeResult:
|
||
"""
|
||
执行循环节点
|
||
|
||
循环节点本身只负责初始化循环状态，实际的循环执行由 WorkflowService 处理
|
||
"""
|
||
try:
|
||
loop_mode = self.config.get('loop_mode', 'for_each')
|
||
max_iterations = self.config.get('max_iterations', 100)
|
||
|
||
if loop_mode == 'for_each':
|
||
return self._init_for_each(context, max_iterations)
|
||
elif loop_mode == 'while':
|
||
return self._init_while(context, max_iterations)
|
||
else:
|
||
return NodeResult(
|
||
success=False,
|
||
error=f'不支持的循环模式: {loop_mode}',
|
||
)
|
||
|
||
except Exception as e:
|
||
logger.exception(f'循环节点执行失败: {e}')
|
||
return NodeResult(
|
||
success=False,
|
||
error=str(e),
|
||
)
|
||
|
||
def _init_for_each(self, context: NodeContext, max_iterations: int) -> NodeResult:
|
||
"""初始化 for_each 循环"""
|
||
items_var = self.config.get('items_variable', '')
|
||
|
||
logger.info(f'[LoopNode] 初始化 for_each 循环，items_variable={items_var}')
|
||
|
||
# 解析数组变量
|
||
items = self._resolve_variable(items_var, context)
|
||
|
||
logger.info(f'[LoopNode] 解析后的 items 类型: {type(items).__name__}, 值: {items}')
|
||
|
||
# 如果是字符串，尝试解析为 JSON 或 Python 字面量
|
||
if isinstance(items, str):
|
||
try:
|
||
items = json.loads(items)
|
||
logger.info(f'[LoopNode] JSON 解析成功，items={items}')
|
||
except json.JSONDecodeError:
|
||
# 尝试使用 ast.literal_eval 解析 Python 字面量（如 str() 输出的列表）
|
||
try:
|
||
items = ast.literal_eval(items)
|
||
logger.info(f'[LoopNode] Python 字面量解析成功，items={items}')
|
||
except (ValueError, SyntaxError):
|
||
# 尝试按逗号分割（仅当不是列表/字典格式时）
|
||
if not (items.strip().startswith('[') or items.strip().startswith('{')):
|
||
items = [item.strip() for item in items.split(',') if item.strip()]
|
||
logger.info(f'[LoopNode] 按逗号分割，items={items}')
|
||
else:
|
||
logger.error(f'[LoopNode] 无法解析 items 字符串: {items[:200]}...')
|
||
return NodeResult(
|
||
success=False,
|
||
error=f'无法解析 items 变量，格式不正确',
|
||
)
|
||
|
||
if not isinstance(items, (list, tuple)):
|
||
error_msg = f'items 必须是数组，当前类型: {type(items).__name__}, 值: {items}, items_variable={items_var}'
|
||
logger.error(f'[LoopNode] {error_msg}')
|
||
return NodeResult(
|
||
success=False,
|
||
error=error_msg,
|
||
)
|
||
|
||
# 检查数组是否为空
|
||
if len(items) == 0:
|
||
logger.warning(f'[LoopNode] items 数组为空，items_variable={items_var}')
|
||
# 返回成功但不执行循环体
|
||
|
||
# 限制最大迭代次数
|
||
if len(items) > max_iterations:
|
||
logger.warning(f'数组长度 {len(items)} 超过最大迭代次数 {max_iterations}，将被截断')
|
||
items = list(items)[:max_iterations]
|
||
|
||
return NodeResult(
|
||
success=True,
|
||
output={
|
||
'items': list(items),
|
||
'total_count': len(items),
|
||
},
|
||
output_variables={
|
||
'_loop_items': list(items),
|
||
'_loop_index': 0,
|
||
'_loop_total': len(items),
|
||
'_loop_mode': 'for_each',
|
||
'_loop_results': [],
|
||
},
|
||
metadata={
|
||
'is_loop': True,
|
||
'loop_mode': 'for_each',
|
||
'total_iterations': len(items),
|
||
'max_iterations': max_iterations,
|
||
},
|
||
)
|
||
|
||
def _init_while(self, context: NodeContext, max_iterations: int) -> NodeResult:
|
||
"""初始化 while 循环"""
|
||
# 检查初始条件
|
||
condition_met = self._evaluate_condition(context)
|
||
|
||
return NodeResult(
|
||
success=True,
|
||
output={
|
||
'condition_met': condition_met,
|
||
},
|
||
output_variables={
|
||
'_loop_index': 0,
|
||
'_loop_mode': 'while',
|
||
'_loop_condition_met': condition_met,
|
||
'_loop_results': [],
|
||
'_loop_max_iterations': max_iterations,
|
||
},
|
||
metadata={
|
||
'is_loop': True,
|
||
'loop_mode': 'while',
|
||
'condition_met': condition_met,
|
||
'max_iterations': max_iterations,
|
||
},
|
||
)
|
||
|
||
def check_continue(self, context: NodeContext) -> bool:
|
||
"""
|
||
检查是否继续循环
|
||
|
||
由 WorkflowService 在每次循环迭代后调用
|
||
"""
|
||
loop_mode = context.get_variable('_loop_mode')
|
||
current_index = context.get_variable('_loop_index', 0)
|
||
max_iterations = self.config.get('max_iterations', 100)
|
||
|
||
# 检查最大迭代次数
|
||
if current_index >= max_iterations:
|
||
logger.warning(f'达到最大迭代次数 {max_iterations}，停止循环')
|
||
return False
|
||
|
||
if loop_mode == 'for_each':
|
||
total = context.get_variable('_loop_total', 0)
|
||
return current_index < total
|
||
elif loop_mode == 'while':
|
||
return self._evaluate_condition(context)
|
||
|
||
return False
|
||
|
||
def get_current_item(self, context: NodeContext) -> Any:
|
||
"""获取当前循环项（for_each 模式）"""
|
||
items = context.get_variable('_loop_items', [])
|
||
index = context.get_variable('_loop_index', 0)
|
||
|
||
if 0 <= index < len(items):
|
||
return items[index]
|
||
return None
|
||
|
||
def increment_index(self, context: NodeContext) -> int:
|
||
"""增加循环索引"""
|
||
current_index = context.get_variable('_loop_index', 0)
|
||
new_index = current_index + 1
|
||
context.set_variable('_loop_index', new_index)
|
||
return new_index
|
||
|
||
def add_result(self, context: NodeContext, result: Any) -> None:
|
||
"""添加循环结果"""
|
||
results = context.get_variable('_loop_results', [])
|
||
results.append(result)
|
||
context.set_variable('_loop_results', results)
|
||
|
||
def _resolve_variable(self, variable: str, context: NodeContext) -> Any:
|
||
"""解析变量引用，支持多层路径访问"""
|
||
if not isinstance(variable, str):
|
||
return variable
|
||
|
||
# 如果是空字符串，返回 None
|
||
if not variable.strip():
|
||
return None
|
||
|
||
# 检查是否是 {{...}} 格式的变量引用
|
||
if not (variable.startswith('{{') and variable.endswith('}}')):
|
||
# 不是变量引用，直接返回原始字符串值（可能是硬编码的 JSON 数组或逗号分隔的值）
|
||
return variable
|
||
|
||
# 使用 resolve_template 解析变量，它支持多层路径访问（如 node.key.subkey）
|
||
resolved = context.resolve_template(variable)
|
||
|
||
# 如果解析结果与原始变量相同，说明变量不存在或解析失败
|
||
if resolved == variable:
|
||
return None
|
||
|
||
# 如果解析结果是字符串，尝试解析为 JSON
|
||
if isinstance(resolved, str):
|
||
try:
|
||
import json
|
||
return json.loads(resolved)
|
||
except (json.JSONDecodeError, TypeError):
|
||
return resolved
|
||
|
||
return resolved
|
||
|
||
def _evaluate_condition(self, context: NodeContext) -> bool:
|
||
"""评估 while 条件"""
|
||
conditions = self.config.get('conditions', [])
|
||
logic = self.config.get('condition_logic', 'and') # and 或 or
|
||
|
||
if not conditions:
|
||
return False # 无条件默认不继续
|
||
|
||
results = []
|
||
for condition in conditions:
|
||
result = self._evaluate_single_condition(condition, context)
|
||
results.append(result)
|
||
|
||
if logic == 'or':
|
||
return any(results)
|
||
else: # and
|
||
return all(results)
|
||
|
||
def _evaluate_single_condition(self, condition: Dict, context: NodeContext) -> bool:
|
||
"""评估单个条件"""
|
||
variable = condition.get('variable', '')
|
||
op_name = condition.get('operator', 'eq')
|
||
value = condition.get('value', '')
|
||
|
||
# 解析变量和值
|
||
left_val = self._resolve_variable(variable, context)
|
||
right_val = self._resolve_variable(value, context) if value else None
|
||
|
||
# 获取操作符函数
|
||
op_func = self.OPERATORS.get(op_name, operator.eq)
|
||
|
||
try:
|
||
# 特殊处理不需要右值的操作符
|
||
if op_name in ['is_empty', 'is_not_empty', 'is_true', 'is_false']:
|
||
return op_func(left_val, None)
|
||
|
||
# 尝试类型转换
|
||
if isinstance(left_val, (int, float)) and isinstance(right_val, str):
|
||
try:
|
||
if '.' in right_val:
|
||
right_val = float(right_val)
|
||
else:
|
||
right_val = int(right_val)
|
||
except ValueError:
|
||
pass
|
||
|
||
return op_func(left_val, right_val)
|
||
except Exception as e:
|
||
logger.warning(f'条件评估失败: {e}')
|
||
return False
|
||
|
||
@classmethod
|
||
def get_config_schema(cls) -> Dict[str, Any]:
|
||
"""获取配置 Schema"""
|
||
return {
|
||
'type': 'object',
|
||
'properties': {
|
||
'loop_mode': {
|
||
'type': 'string',
|
||
'title': '循环模式',
|
||
'enum': ['for_each', 'while'],
|
||
'enumNames': ['遍历数组 (For Each)', '条件循环 (While)'],
|
||
'default': 'for_each',
|
||
},
|
||
'items_variable': {
|
||
'type': 'string',
|
||
'title': '数组变量',
|
||
'description': '要遍历的数组变量名（for_each 模式）',
|
||
},
|
||
'item_variable_name': {
|
||
'type': 'string',
|
||
'title': '循环项变量名',
|
||
'description': '当前循环项的变量名，默认为 item',
|
||
'default': 'item',
|
||
},
|
||
'index_variable_name': {
|
||
'type': 'string',
|
||
'title': '索引变量名',
|
||
'description': '当前索引的变量名，默认为 index',
|
||
'default': 'index',
|
||
},
|
||
'conditions': {
|
||
'type': 'array',
|
||
'title': '循环条件',
|
||
'description': 'while 模式的循环条件',
|
||
'items': {
|
||
'type': 'object',
|
||
'properties': {
|
||
'variable': {
|
||
'type': 'string',
|
||
'title': '变量',
|
||
},
|
||
'operator': {
|
||
'type': 'string',
|
||
'title': '操作符',
|
||
'enum': list(cls.OPERATORS.keys()),
|
||
'default': 'eq',
|
||
},
|
||
'value': {
|
||
'type': 'string',
|
||
'title': '比较值',
|
||
},
|
||
},
|
||
},
|
||
},
|
||
'condition_logic': {
|
||
'type': 'string',
|
||
'title': '条件逻辑',
|
||
'enum': ['and', 'or'],
|
||
'enumNames': ['全部满足 (AND)', '任一满足 (OR)'],
|
||
'default': 'and',
|
||
},
|
||
'max_iterations': {
|
||
'type': 'integer',
|
||
'title': '最大迭代次数',
|
||
'description': '防止无限循环，默认 100 次',
|
||
'default': 100,
|
||
'minimum': 1,
|
||
'maximum': 10000,
|
||
},
|
||
'output_variable': {
|
||
'type': 'string',
|
||
'title': '输出变量名',
|
||
'description': '存储所有循环结果的变量名',
|
||
'default': 'loop_results',
|
||
},
|
||
},
|
||
}
|
||
|
||
|