refactor: move workflow package to dify_graph (#32844)

api/dify_graph/nodes/variable_assigner/common/exc.py

@@ -0,0 +1,4 @@
+class VariableOperatorNodeError(ValueError):
+    """Base error type, don't use directly."""
+
+    pass

api/dify_graph/nodes/variable_assigner/common/helpers.py

@@ -0,0 +1,55 @@
+from collections.abc import Mapping, MutableMapping, Sequence
+from typing import Any, TypeVar
+
+from pydantic import BaseModel
+
+from dify_graph.variables import Segment
+from dify_graph.variables.consts import SELECTORS_LENGTH
+from dify_graph.variables.types import SegmentType
+
+# Use double underscore (`__`) prefix for internal variables
+# to minimize risk of collision with user-defined variable names.
+_UPDATED_VARIABLES_KEY = "__updated_variables"
+
+
+class UpdatedVariable(BaseModel):
+    name: str
+    selector: Sequence[str]
+    value_type: SegmentType
+    new_value: Any = None
+
+
+_T = TypeVar("_T", bound=MutableMapping[str, Any])
+
+
+def variable_to_processed_data(selector: Sequence[str], seg: Segment) -> UpdatedVariable:
+    if len(selector) < SELECTORS_LENGTH:
+        raise Exception("selector too short")
+    _, var_name = selector[:2]
+    return UpdatedVariable(
+        name=var_name,
+        selector=list(selector[:2]),
+        value_type=seg.value_type,
+        new_value=seg.value,
+    )
+
+
+def set_updated_variables(m: _T, updates: Sequence[UpdatedVariable]) -> _T:
+    m[_UPDATED_VARIABLES_KEY] = updates
+    return m
+
+
+def get_updated_variables(m: Mapping[str, Any]) -> Sequence[UpdatedVariable] | None:
+    updated_values = m.get(_UPDATED_VARIABLES_KEY, None)
+    if updated_values is None:
+        return None
+    result = []
+    for items in updated_values:
+        if isinstance(items, UpdatedVariable):
+            result.append(items)
+        elif isinstance(items, dict):
+            items = UpdatedVariable.model_validate(items)
+            result.append(items)
+        else:
+            raise TypeError(f"Invalid updated variable: {items}, type={type(items)}")
+    return result

api/dify_graph/nodes/variable_assigner/v1/__init__.py

@@ -0,0 +1,3 @@
+from .node import VariableAssignerNode
+
+__all__ = ["VariableAssignerNode"]

api/dify_graph/nodes/variable_assigner/v1/node.py

@@ -0,0 +1,111 @@
+from collections.abc import Mapping, Sequence
+from typing import TYPE_CHECKING, Any
+
+from dify_graph.constants import CONVERSATION_VARIABLE_NODE_ID
+from dify_graph.entities import GraphInitParams
+from dify_graph.enums import NodeType, WorkflowNodeExecutionStatus
+from dify_graph.node_events import NodeRunResult
+from dify_graph.nodes.base.node import Node
+from dify_graph.nodes.variable_assigner.common import helpers as common_helpers
+from dify_graph.nodes.variable_assigner.common.exc import VariableOperatorNodeError
+from dify_graph.variables import SegmentType, VariableBase
+
+from .node_data import VariableAssignerData, WriteMode
+
+if TYPE_CHECKING:
+    from dify_graph.runtime import GraphRuntimeState
+
+
+class VariableAssignerNode(Node[VariableAssignerData]):
+    node_type = NodeType.VARIABLE_ASSIGNER
+
+    def __init__(
+        self,
+        id: str,
+        config: Mapping[str, Any],
+        graph_init_params: "GraphInitParams",
+        graph_runtime_state: "GraphRuntimeState",
+    ):
+        super().__init__(
+            id=id,
+            config=config,
+            graph_init_params=graph_init_params,
+            graph_runtime_state=graph_runtime_state,
+        )
+
+    def blocks_variable_output(self, variable_selectors: set[tuple[str, ...]]) -> bool:
+        """
+        Check if this Variable Assigner node blocks the output of specific variables.
+
+        Returns True if this node updates any of the requested conversation variables.
+        """
+        assigned_selector = tuple(self.node_data.assigned_variable_selector)
+        return assigned_selector in variable_selectors
+
+    @classmethod
+    def version(cls) -> str:
+        return "1"
+
+    @classmethod
+    def _extract_variable_selector_to_variable_mapping(
+        cls,
+        *,
+        graph_config: Mapping[str, Any],
+        node_id: str,
+        node_data: Mapping[str, Any],
+    ) -> Mapping[str, Sequence[str]]:
+        # Create typed NodeData from dict
+        typed_node_data = VariableAssignerData.model_validate(node_data)
+
+        mapping = {}
+        assigned_variable_node_id = typed_node_data.assigned_variable_selector[0]
+        if assigned_variable_node_id == CONVERSATION_VARIABLE_NODE_ID:
+            selector_key = ".".join(typed_node_data.assigned_variable_selector)
+            key = f"{node_id}.#{selector_key}#"
+            mapping[key] = typed_node_data.assigned_variable_selector
+
+        selector_key = ".".join(typed_node_data.input_variable_selector)
+        key = f"{node_id}.#{selector_key}#"
+        mapping[key] = typed_node_data.input_variable_selector
+        return mapping
+
+    def _run(self) -> NodeRunResult:
+        assigned_variable_selector = self.node_data.assigned_variable_selector
+        # Should be String, Number, Object, ArrayString, ArrayNumber, ArrayObject
+        original_variable = self.graph_runtime_state.variable_pool.get(assigned_variable_selector)
+        if not isinstance(original_variable, VariableBase):
+            raise VariableOperatorNodeError("assigned variable not found")
+
+        match self.node_data.write_mode:
+            case WriteMode.OVER_WRITE:
+                income_value = self.graph_runtime_state.variable_pool.get(self.node_data.input_variable_selector)
+                if not income_value:
+                    raise VariableOperatorNodeError("input value not found")
+                updated_variable = original_variable.model_copy(update={"value": income_value.value})
+
+            case WriteMode.APPEND:
+                income_value = self.graph_runtime_state.variable_pool.get(self.node_data.input_variable_selector)
+                if not income_value:
+                    raise VariableOperatorNodeError("input value not found")
+                updated_value = original_variable.value + [income_value.value]
+                updated_variable = original_variable.model_copy(update={"value": updated_value})
+
+            case WriteMode.CLEAR:
+                income_value = SegmentType.get_zero_value(original_variable.value_type)
+                updated_variable = original_variable.model_copy(update={"value": income_value.to_object()})
+
+        # Over write the variable.
+        self.graph_runtime_state.variable_pool.add(assigned_variable_selector, updated_variable)
+
+        updated_variables = [common_helpers.variable_to_processed_data(assigned_variable_selector, updated_variable)]
+        return NodeRunResult(
+            status=WorkflowNodeExecutionStatus.SUCCEEDED,
+            inputs={
+                "value": income_value.to_object(),
+            },
+            # NOTE(QuantumGhost): although only one variable is updated in `v1.VariableAssignerNode`,
+            # we still set `output_variables` as a list to ensure the schema of output is
+            # compatible with `v2.VariableAssignerNode`.
+            process_data=common_helpers.set_updated_variables({}, updated_variables),
+            outputs={},
+        )

api/dify_graph/nodes/variable_assigner/v1/node_data.py

@@ -0,0 +1,16 @@
+from collections.abc import Sequence
+from enum import StrEnum
+
+from dify_graph.nodes.base import BaseNodeData
+
+
+class WriteMode(StrEnum):
+    OVER_WRITE = "over-write"
+    APPEND = "append"
+    CLEAR = "clear"
+
+
+class VariableAssignerData(BaseNodeData):
+    assigned_variable_selector: Sequence[str]
+    write_mode: WriteMode
+    input_variable_selector: Sequence[str]

api/dify_graph/nodes/variable_assigner/v2/__init__.py

@@ -0,0 +1,3 @@
+from .node import VariableAssignerNode
+
+__all__ = ["VariableAssignerNode"]

api/dify_graph/nodes/variable_assigner/v2/entities.py

@@ -0,0 +1,26 @@
+from collections.abc import Sequence
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+from dify_graph.nodes.base import BaseNodeData
+
+from .enums import InputType, Operation
+
+
+class VariableOperationItem(BaseModel):
+    variable_selector: Sequence[str]
+    input_type: InputType
+    operation: Operation
+    # NOTE(QuantumGhost): The `value` field serves multiple purposes depending on context:
+    #
+    # 1. For CONSTANT input_type: Contains the literal value to be used in the operation.
+    # 2. For VARIABLE input_type: Initially contains the selector of the source variable.
+    # 3. During the variable updating procedure: The `value` field is reassigned to hold
+    #    the resolved actual value that will be applied to the target variable.
+    value: Any = None
+
+
+class VariableAssignerNodeData(BaseNodeData):
+    version: str = "2"
+    items: Sequence[VariableOperationItem] = Field(default_factory=list)

api/dify_graph/nodes/variable_assigner/v2/enums.py

@@ -0,0 +1,20 @@
+from enum import StrEnum
+
+
+class Operation(StrEnum):
+    OVER_WRITE = "over-write"
+    CLEAR = "clear"
+    APPEND = "append"
+    EXTEND = "extend"
+    SET = "set"
+    ADD = "+="
+    SUBTRACT = "-="
+    MULTIPLY = "*="
+    DIVIDE = "/="
+    REMOVE_FIRST = "remove-first"
+    REMOVE_LAST = "remove-last"
+
+
+class InputType(StrEnum):
+    VARIABLE = "variable"
+    CONSTANT = "constant"

api/dify_graph/nodes/variable_assigner/v2/exc.py

@@ -0,0 +1,36 @@
+from collections.abc import Sequence
+from typing import Any
+
+from dify_graph.nodes.variable_assigner.common.exc import VariableOperatorNodeError
+
+from .enums import InputType, Operation
+
+
+class OperationNotSupportedError(VariableOperatorNodeError):
+    def __init__(self, *, operation: Operation, variable_type: str):
+        super().__init__(f"Operation {operation} is not supported for type {variable_type}")
+
+
+class InputTypeNotSupportedError(VariableOperatorNodeError):
+    def __init__(self, *, input_type: InputType, operation: Operation):
+        super().__init__(f"Input type {input_type} is not supported for operation {operation}")
+
+
+class VariableNotFoundError(VariableOperatorNodeError):
+    def __init__(self, *, variable_selector: Sequence[str]):
+        super().__init__(f"Variable {variable_selector} not found")
+
+
+class InvalidInputValueError(VariableOperatorNodeError):
+    def __init__(self, *, value: Any):
+        super().__init__(f"Invalid input value {value}")
+
+
+class ConversationIDNotFoundError(VariableOperatorNodeError):
+    def __init__(self):
+        super().__init__("conversation_id not found")
+
+
+class InvalidDataError(VariableOperatorNodeError):
+    def __init__(self, message: str):
+        super().__init__(message)

api/dify_graph/nodes/variable_assigner/v2/helpers.py

@@ -0,0 +1,98 @@
+from typing import Any
+
+from dify_graph.variables import SegmentType
+
+from .enums import Operation
+
+
+def is_operation_supported(*, variable_type: SegmentType, operation: Operation):
+    match operation:
+        case Operation.OVER_WRITE | Operation.CLEAR:
+            return True
+        case Operation.SET:
+            return variable_type in {
+                SegmentType.OBJECT,
+                SegmentType.STRING,
+                SegmentType.NUMBER,
+                SegmentType.INTEGER,
+                SegmentType.FLOAT,
+                SegmentType.BOOLEAN,
+            }
+        case Operation.ADD | Operation.SUBTRACT | Operation.MULTIPLY | Operation.DIVIDE:
+            # Only number variable can be added, subtracted, multiplied or divided
+            return variable_type in {SegmentType.NUMBER, SegmentType.INTEGER, SegmentType.FLOAT}
+        case Operation.APPEND | Operation.EXTEND | Operation.REMOVE_FIRST | Operation.REMOVE_LAST:
+            # Only array variable can be appended or extended
+            # Only array variable can have elements removed
+            return variable_type.is_array_type()
+
+
+def is_variable_input_supported(*, operation: Operation):
+    if operation in {Operation.SET, Operation.ADD, Operation.SUBTRACT, Operation.MULTIPLY, Operation.DIVIDE}:
+        return False
+    return True
+
+
+def is_constant_input_supported(*, variable_type: SegmentType, operation: Operation):
+    match variable_type:
+        case SegmentType.STRING | SegmentType.OBJECT | SegmentType.BOOLEAN:
+            return operation in {Operation.OVER_WRITE, Operation.SET}
+        case SegmentType.NUMBER | SegmentType.INTEGER | SegmentType.FLOAT:
+            return operation in {
+                Operation.OVER_WRITE,
+                Operation.SET,
+                Operation.ADD,
+                Operation.SUBTRACT,
+                Operation.MULTIPLY,
+                Operation.DIVIDE,
+            }
+        case _:
+            return False
+
+
+def is_input_value_valid(*, variable_type: SegmentType, operation: Operation, value: Any):
+    if operation in {Operation.CLEAR, Operation.REMOVE_FIRST, Operation.REMOVE_LAST}:
+        return True
+    match variable_type:
+        case SegmentType.STRING:
+            return isinstance(value, str)
+
+        case SegmentType.BOOLEAN:
+            return isinstance(value, bool)
+
+        case SegmentType.NUMBER | SegmentType.INTEGER | SegmentType.FLOAT:
+            if not isinstance(value, int | float):
+                return False
+            if operation == Operation.DIVIDE and value == 0:
+                return False
+            return True
+
+        case SegmentType.OBJECT:
+            return isinstance(value, dict)
+
+        # Array & Append
+        case SegmentType.ARRAY_ANY if operation == Operation.APPEND:
+            return isinstance(value, str | float | int | dict)
+        case SegmentType.ARRAY_STRING if operation == Operation.APPEND:
+            return isinstance(value, str)
+        case SegmentType.ARRAY_NUMBER if operation == Operation.APPEND:
+            return isinstance(value, int | float)
+        case SegmentType.ARRAY_OBJECT if operation == Operation.APPEND:
+            return isinstance(value, dict)
+        case SegmentType.ARRAY_BOOLEAN if operation == Operation.APPEND:
+            return isinstance(value, bool)
+
+        # Array & Extend / Overwrite
+        case SegmentType.ARRAY_ANY if operation in {Operation.EXTEND, Operation.OVER_WRITE}:
+            return isinstance(value, list) and all(isinstance(item, str | float | int | dict) for item in value)
+        case SegmentType.ARRAY_STRING if operation in {Operation.EXTEND, Operation.OVER_WRITE}:
+            return isinstance(value, list) and all(isinstance(item, str) for item in value)
+        case SegmentType.ARRAY_NUMBER if operation in {Operation.EXTEND, Operation.OVER_WRITE}:
+            return isinstance(value, list) and all(isinstance(item, int | float) for item in value)
+        case SegmentType.ARRAY_OBJECT if operation in {Operation.EXTEND, Operation.OVER_WRITE}:
+            return isinstance(value, list) and all(isinstance(item, dict) for item in value)
+        case SegmentType.ARRAY_BOOLEAN if operation in {Operation.EXTEND, Operation.OVER_WRITE}:
+            return isinstance(value, list) and all(isinstance(item, bool) for item in value)
+
+        case _:
+            return False

api/dify_graph/nodes/variable_assigner/v2/node.py

@@ -0,0 +1,248 @@
+import json
+from collections.abc import Mapping, MutableMapping, Sequence
+from typing import TYPE_CHECKING, Any
+
+from dify_graph.constants import CONVERSATION_VARIABLE_NODE_ID
+from dify_graph.enums import NodeType, WorkflowNodeExecutionStatus
+from dify_graph.node_events import NodeRunResult
+from dify_graph.nodes.base.node import Node
+from dify_graph.nodes.variable_assigner.common import helpers as common_helpers
+from dify_graph.nodes.variable_assigner.common.exc import VariableOperatorNodeError
+from dify_graph.variables import SegmentType, VariableBase
+from dify_graph.variables.consts import SELECTORS_LENGTH
+
+from . import helpers
+from .entities import VariableAssignerNodeData, VariableOperationItem
+from .enums import InputType, Operation
+from .exc import (
+    InputTypeNotSupportedError,
+    InvalidDataError,
+    InvalidInputValueError,
+    OperationNotSupportedError,
+    VariableNotFoundError,
+)
+
+if TYPE_CHECKING:
+    from dify_graph.entities import GraphInitParams
+    from dify_graph.runtime import GraphRuntimeState
+
+
+def _target_mapping_from_item(mapping: MutableMapping[str, Sequence[str]], node_id: str, item: VariableOperationItem):
+    selector_node_id = item.variable_selector[0]
+    if selector_node_id != CONVERSATION_VARIABLE_NODE_ID:
+        return
+    selector_str = ".".join(item.variable_selector)
+    key = f"{node_id}.#{selector_str}#"
+    mapping[key] = item.variable_selector
+
+
+def _source_mapping_from_item(mapping: MutableMapping[str, Sequence[str]], node_id: str, item: VariableOperationItem):
+    # Keep this in sync with the logic in _run methods...
+    if item.input_type != InputType.VARIABLE:
+        return
+    selector = item.value
+    if not isinstance(selector, list):
+        raise InvalidDataError(f"selector is not a list, {node_id=}, {item=}")
+    if len(selector) < SELECTORS_LENGTH:
+        raise InvalidDataError(f"selector too short, {node_id=}, {item=}")
+    selector_str = ".".join(selector)
+    key = f"{node_id}.#{selector_str}#"
+    mapping[key] = selector
+
+
+class VariableAssignerNode(Node[VariableAssignerNodeData]):
+    node_type = NodeType.VARIABLE_ASSIGNER
+
+    def __init__(
+        self,
+        id: str,
+        config: Mapping[str, Any],
+        graph_init_params: "GraphInitParams",
+        graph_runtime_state: "GraphRuntimeState",
+    ):
+        super().__init__(
+            id=id,
+            config=config,
+            graph_init_params=graph_init_params,
+            graph_runtime_state=graph_runtime_state,
+        )
+
+    def blocks_variable_output(self, variable_selectors: set[tuple[str, ...]]) -> bool:
+        """
+        Check if this Variable Assigner node blocks the output of specific variables.
+
+        Returns True if this node updates any of the requested conversation variables.
+        """
+        # Check each item in this Variable Assigner node
+        for item in self.node_data.items:
+            # Convert the item's variable_selector to tuple for comparison
+            item_selector_tuple = tuple(item.variable_selector)
+
+            # Check if this item updates any of the requested variables
+            if item_selector_tuple in variable_selectors:
+                return True
+
+        return False
+
+    @classmethod
+    def version(cls) -> str:
+        return "2"
+
+    @classmethod
+    def _extract_variable_selector_to_variable_mapping(
+        cls,
+        *,
+        graph_config: Mapping[str, Any],
+        node_id: str,
+        node_data: Mapping[str, Any],
+    ) -> Mapping[str, Sequence[str]]:
+        # Create typed NodeData from dict
+        typed_node_data = VariableAssignerNodeData.model_validate(node_data)
+
+        var_mapping: dict[str, Sequence[str]] = {}
+        for item in typed_node_data.items:
+            _target_mapping_from_item(var_mapping, node_id, item)
+            _source_mapping_from_item(var_mapping, node_id, item)
+        return var_mapping
+
+    def _run(self) -> NodeRunResult:
+        inputs = self.node_data.model_dump()
+        process_data: dict[str, Any] = {}
+        # NOTE: This node has no outputs
+        updated_variable_selectors: list[Sequence[str]] = []
+
+        try:
+            for item in self.node_data.items:
+                variable = self.graph_runtime_state.variable_pool.get(item.variable_selector)
+
+                # ==================== Validation Part
+
+                # Check if variable exists
+                if not isinstance(variable, VariableBase):
+                    raise VariableNotFoundError(variable_selector=item.variable_selector)
+
+                # Check if operation is supported
+                if not helpers.is_operation_supported(variable_type=variable.value_type, operation=item.operation):
+                    raise OperationNotSupportedError(operation=item.operation, variable_type=variable.value_type)
+
+                # Check if variable input is supported
+                if item.input_type == InputType.VARIABLE and not helpers.is_variable_input_supported(
+                    operation=item.operation
+                ):
+                    raise InputTypeNotSupportedError(input_type=InputType.VARIABLE, operation=item.operation)
+
+                # Check if constant input is supported
+                if item.input_type == InputType.CONSTANT and not helpers.is_constant_input_supported(
+                    variable_type=variable.value_type, operation=item.operation
+                ):
+                    raise InputTypeNotSupportedError(input_type=InputType.CONSTANT, operation=item.operation)
+
+                # Get value from variable pool
+                if (
+                    item.input_type == InputType.VARIABLE
+                    and item.operation not in {Operation.CLEAR, Operation.REMOVE_FIRST, Operation.REMOVE_LAST}
+                    and item.value is not None
+                ):
+                    value = self.graph_runtime_state.variable_pool.get(item.value)
+                    if value is None:
+                        raise VariableNotFoundError(variable_selector=item.value)
+                    # Skip if value is NoneSegment
+                    if value.value_type == SegmentType.NONE:
+                        continue
+                    item.value = value.value
+
+                # If set string / bytes / bytearray to object, try convert string to object.
+                if (
+                    item.operation == Operation.SET
+                    and variable.value_type == SegmentType.OBJECT
+                    and isinstance(item.value, str | bytes | bytearray)
+                ):
+                    try:
+                        item.value = json.loads(item.value)
+                    except json.JSONDecodeError:
+                        raise InvalidInputValueError(value=item.value)
+
+                # Check if input value is valid
+                if not helpers.is_input_value_valid(
+                    variable_type=variable.value_type, operation=item.operation, value=item.value
+                ):
+                    raise InvalidInputValueError(value=item.value)
+
+                # ==================== Execution Part
+
+                updated_value = self._handle_item(
+                    variable=variable,
+                    operation=item.operation,
+                    value=item.value,
+                )
+                variable = variable.model_copy(update={"value": updated_value})
+                self.graph_runtime_state.variable_pool.add(variable.selector, variable)
+                updated_variable_selectors.append(variable.selector)
+        except VariableOperatorNodeError as e:
+            return NodeRunResult(
+                status=WorkflowNodeExecutionStatus.FAILED,
+                inputs=inputs,
+                process_data=process_data,
+                error=str(e),
+            )
+
+        # The `updated_variable_selectors` is a list contains list[str] which not hashable,
+        # remove the duplicated items first.
+        updated_variable_selectors = list(set(map(tuple, updated_variable_selectors)))
+
+        for selector in updated_variable_selectors:
+            variable = self.graph_runtime_state.variable_pool.get(selector)
+            if not isinstance(variable, VariableBase):
+                raise VariableNotFoundError(variable_selector=selector)
+            process_data[variable.name] = variable.value
+
+        updated_variables = [
+            common_helpers.variable_to_processed_data(selector, seg)
+            for selector in updated_variable_selectors
+            if (seg := self.graph_runtime_state.variable_pool.get(selector)) is not None
+        ]
+
+        process_data = common_helpers.set_updated_variables(process_data, updated_variables)
+        return NodeRunResult(
+            status=WorkflowNodeExecutionStatus.SUCCEEDED,
+            inputs=inputs,
+            process_data=process_data,
+            outputs={},
+        )
+
+    def _handle_item(
+        self,
+        *,
+        variable: VariableBase,
+        operation: Operation,
+        value: Any,
+    ):
+        match operation:
+            case Operation.OVER_WRITE:
+                return value
+            case Operation.CLEAR:
+                return SegmentType.get_zero_value(variable.value_type).to_object()
+            case Operation.APPEND:
+                return variable.value + [value]
+            case Operation.EXTEND:
+                return variable.value + value
+            case Operation.SET:
+                return value
+            case Operation.ADD:
+                return variable.value + value
+            case Operation.SUBTRACT:
+                return variable.value - value
+            case Operation.MULTIPLY:
+                return variable.value * value
+            case Operation.DIVIDE:
+                return variable.value / value
+            case Operation.REMOVE_FIRST:
+                # If array is empty, do nothing
+                if not variable.value:
+                    return variable.value
+                return variable.value[1:]
+            case Operation.REMOVE_LAST:
+                # If array is empty, do nothing
+                if not variable.value:
+                    return variable.value
+                return variable.value[:-1]