初始化
This commit is contained in:
1 parent
34474bd5fc
commit
b638b541d0
3008 files changed
+837699
No files matched your search
@@ -0,0 +1,267 @@
|
||||
"""Safe expression / template evaluation for workflow node configs.
|
||||
|
||||
Two surfaces, both intentionally tiny:
|
||||
|
||||
* ``render_template("… {{ nodes.a.data.title }} …", state)`` — string
|
||||
interpolation over a whitelisted state tree.
|
||||
* ``evaluate_condition("nodes.a.data.score > 0.5", state)`` — boolean
|
||||
predicate over the same tree.
|
||||
|
||||
Neither uses :func:`eval`. The condition grammar is a single comparison or a
|
||||
chain joined by ``and`` / ``or``; operands are either a state path or a JSON
|
||||
literal. Anything else raises ``WORKFLOW_EXPRESSION_INVALID`` so a malformed
|
||||
graph fails loudly at publish time instead of silently at run time.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import re
|
||||
from typing import Any
|
||||
|
||||
from deerflow.workflows.errors import WorkflowError
|
||||
|
||||
_TEMPLATE_RE = re.compile(r"\{\{\s*([^{}]+?)\s*\}\}")
|
||||
_ROOT_KEYS = ("inputs", "nodes", "run", "loop", "env")
|
||||
# Coze canvas node ids are commonly numeric (for example ``100001``). They
|
||||
# are still dictionary keys, not Python identifiers, so permit a numeric
|
||||
# dotted segment while keeping roots and normal field names restricted.
|
||||
_PATH_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*(?:\.(?:[A-Za-z_][A-Za-z0-9_\-]*|\d+)|\[\d+\])*$")
|
||||
_COMPARATORS = ("==", "!=", ">=", "<=", ">", "<", " in ", " contains ")
|
||||
_MAX_RENDER_CHARS = 200_000
|
||||
|
||||
|
||||
def _invalid(expr: str, reason: str) -> WorkflowError:
|
||||
return WorkflowError(
|
||||
"WORKFLOW_EXPRESSION_INVALID",
|
||||
f"表达式不合法:{reason}",
|
||||
details={"expression": expr[:200]},
|
||||
)
|
||||
|
||||
|
||||
def resolve_path(path: str, state: dict[str, Any]) -> Any:
|
||||
"""Read ``a.b[0].c`` from the state tree. Missing segments yield ``None``."""
|
||||
expr = path.strip()
|
||||
if not _PATH_RE.match(expr):
|
||||
raise _invalid(expr, "路径格式不合法")
|
||||
root = expr.split(".", 1)[0].split("[", 1)[0]
|
||||
if root not in _ROOT_KEYS:
|
||||
raise _invalid(expr, f"根节点必须是 {'/'.join(_ROOT_KEYS)} 之一")
|
||||
current: Any = state
|
||||
for segment in re.findall(r"[A-Za-z_][A-Za-z0-9_\-]*|\d+|\[\d+\]", expr):
|
||||
if current is None:
|
||||
return None
|
||||
if segment.startswith("["):
|
||||
index = int(segment[1:-1])
|
||||
if not isinstance(current, (list, tuple)) or index >= len(current):
|
||||
return None
|
||||
current = current[index]
|
||||
elif isinstance(current, dict):
|
||||
current = current.get(segment)
|
||||
else:
|
||||
return None
|
||||
return current
|
||||
|
||||
|
||||
def _stringify(value: Any) -> str:
|
||||
if value is None:
|
||||
return ""
|
||||
if isinstance(value, str):
|
||||
return value
|
||||
if isinstance(value, bool):
|
||||
return "true" if value else "false"
|
||||
if isinstance(value, (int, float)):
|
||||
return str(value)
|
||||
return json.dumps(value, ensure_ascii=False, default=str)
|
||||
|
||||
|
||||
def render_template(template: str, state: dict[str, Any]) -> str:
|
||||
"""Replace every ``{{ path }}`` with its stringified state value."""
|
||||
if not template:
|
||||
return ""
|
||||
|
||||
def _sub(match: re.Match[str]) -> str:
|
||||
return _stringify(resolve_path(match.group(1), state))
|
||||
|
||||
rendered = _TEMPLATE_RE.sub(_sub, template)
|
||||
if len(rendered) > _MAX_RENDER_CHARS:
|
||||
raise WorkflowError(
|
||||
"WORKFLOW_LIMIT_EXCEEDED",
|
||||
"模板渲染结果超出长度上限",
|
||||
details={"limit": _MAX_RENDER_CHARS},
|
||||
)
|
||||
return rendered
|
||||
|
||||
|
||||
def render_value(value: Any, state: dict[str, Any]) -> Any:
|
||||
"""Recursively render templates inside dict / list / str structures.
|
||||
|
||||
A string that is exactly one ``{{ path }}`` keeps the resolved value's
|
||||
native type instead of being stringified.
|
||||
"""
|
||||
if isinstance(value, str):
|
||||
match = _TEMPLATE_RE.fullmatch(value.strip())
|
||||
if match:
|
||||
return resolve_path(match.group(1), state)
|
||||
return render_template(value, state)
|
||||
if isinstance(value, dict):
|
||||
return {k: render_value(v, state) for k, v in value.items()}
|
||||
if isinstance(value, list):
|
||||
return [render_value(v, state) for v in value]
|
||||
return value
|
||||
|
||||
|
||||
def _operand(token: str, state: dict[str, Any]) -> Any:
|
||||
text = token.strip()
|
||||
if not text:
|
||||
raise _invalid(token, "操作数为空")
|
||||
match = _TEMPLATE_RE.fullmatch(text)
|
||||
if match:
|
||||
return resolve_path(match.group(1), state)
|
||||
lowered = text.lower()
|
||||
if lowered in ("true", "false"):
|
||||
return lowered == "true"
|
||||
if lowered in ("null", "none"):
|
||||
return None
|
||||
if (text[0], text[-1]) in (('"', '"'), ("'", "'")) and len(text) >= 2:
|
||||
return text[1:-1]
|
||||
try:
|
||||
return json.loads(text)
|
||||
except json.JSONDecodeError:
|
||||
pass
|
||||
if _PATH_RE.match(text) and text.split(".", 1)[0].split("[", 1)[0] in _ROOT_KEYS:
|
||||
return resolve_path(text, state)
|
||||
return text
|
||||
|
||||
|
||||
def _truthy(value: Any) -> bool:
|
||||
if isinstance(value, str):
|
||||
return value.strip().lower() not in ("", "false", "0", "null", "none")
|
||||
return bool(value)
|
||||
|
||||
|
||||
def _compare(left: Any, op: str, right: Any) -> bool:
|
||||
if op == "==":
|
||||
return left == right
|
||||
if op == "!=":
|
||||
return left != right
|
||||
if op == "in":
|
||||
try:
|
||||
return left in right # type: ignore[operator]
|
||||
except TypeError:
|
||||
return False
|
||||
if op == "contains":
|
||||
try:
|
||||
return right in left # type: ignore[operator]
|
||||
except TypeError:
|
||||
return False
|
||||
try:
|
||||
if op == ">":
|
||||
return left > right
|
||||
if op == "<":
|
||||
return left < right
|
||||
if op == ">=":
|
||||
return left >= right
|
||||
if op == "<=":
|
||||
return left <= right
|
||||
except TypeError:
|
||||
return False
|
||||
raise _invalid(op, f"不支持的比较运算符 {op}")
|
||||
|
||||
|
||||
def _split_top_level(expr: str, keyword: str) -> list[str] | None:
|
||||
"""Split on ``keyword`` outside quotes / braces; None when absent."""
|
||||
parts: list[str] = []
|
||||
depth = 0
|
||||
quote: str | None = None
|
||||
buffer: list[str] = []
|
||||
index = 0
|
||||
pattern = f" {keyword} "
|
||||
while index < len(expr):
|
||||
char = expr[index]
|
||||
if quote:
|
||||
buffer.append(char)
|
||||
if char == quote:
|
||||
quote = None
|
||||
index += 1
|
||||
continue
|
||||
if char in ('"', "'"):
|
||||
quote = char
|
||||
buffer.append(char)
|
||||
index += 1
|
||||
continue
|
||||
if char in "[{(":
|
||||
depth += 1
|
||||
elif char in "]})":
|
||||
depth -= 1
|
||||
if depth == 0 and expr[index : index + len(pattern)] == pattern:
|
||||
parts.append("".join(buffer))
|
||||
buffer = []
|
||||
index += len(pattern)
|
||||
continue
|
||||
buffer.append(char)
|
||||
index += 1
|
||||
if not parts:
|
||||
return None
|
||||
parts.append("".join(buffer))
|
||||
return parts
|
||||
|
||||
|
||||
def evaluate_condition(expression: str, state: dict[str, Any]) -> bool:
|
||||
"""Evaluate a boolean predicate without ``eval``."""
|
||||
expr = (expression or "").strip()
|
||||
if not expr:
|
||||
return False
|
||||
|
||||
or_parts = _split_top_level(expr, "or")
|
||||
if or_parts:
|
||||
return any(evaluate_condition(part, state) for part in or_parts)
|
||||
and_parts = _split_top_level(expr, "and")
|
||||
if and_parts:
|
||||
return all(evaluate_condition(part, state) for part in and_parts)
|
||||
|
||||
if expr.startswith("not "):
|
||||
return not evaluate_condition(expr[4:], state)
|
||||
if expr.startswith("(") and expr.endswith(")"):
|
||||
return evaluate_condition(expr[1:-1], state)
|
||||
|
||||
for comparator in _COMPARATORS:
|
||||
op = comparator.strip()
|
||||
index = expr.find(comparator)
|
||||
if index <= 0:
|
||||
continue
|
||||
left = _operand(expr[:index], state)
|
||||
right = _operand(expr[index + len(comparator) :], state)
|
||||
return _compare(left, op, right)
|
||||
|
||||
return _truthy(_operand(expr, state))
|
||||
|
||||
|
||||
_NODES_IDENT_RE = re.compile(r"(?:\{\{\s*)?nodes\.([A-Za-z_0-9][A-Za-z0-9_\-]*)")
|
||||
|
||||
|
||||
def collect_referenced_nodes(value: Any) -> set[str]:
|
||||
"""Node ids referenced through ``nodes.<id>`` anywhere in a config tree.
|
||||
|
||||
Covers both ``{{ nodes.x.data }}`` templates and bare condition paths
|
||||
such as ``nodes.x.data.score > 0.5``.
|
||||
"""
|
||||
found: set[str] = set()
|
||||
if isinstance(value, str):
|
||||
found.update(_NODES_IDENT_RE.findall(value))
|
||||
elif isinstance(value, dict):
|
||||
for item in value.values():
|
||||
found |= collect_referenced_nodes(item)
|
||||
elif isinstance(value, list):
|
||||
for item in value:
|
||||
found |= collect_referenced_nodes(item)
|
||||
return found
|
||||
|
||||
|
||||
__all__ = [
|
||||
"collect_referenced_nodes",
|
||||
"evaluate_condition",
|
||||
"render_template",
|
||||
"render_value",
|
||||
"resolve_path",
|
||||
]
|
||||
Reference in new issue
Block a user