fix(nodes): keep every key of an AND group in parentheses

scrapegraphai/nodes/base_node.py

@@ -214,7 +214,7 @@ def evaluate_expression(expression: str) -> List[str]:
                 sub_result = evaluate_simple_expression(sub_exp)
 
                 expression = (
-                    expression[:start] + "|".join(sub_result) + expression[end + 1 :]
+                    expression[:start] + "&".join(sub_result) + expression[end + 1 :]
                 )
             return evaluate_simple_expression(expression)
 

scrapegraphai/utils/parse_state_keys.py

@@ -86,7 +86,7 @@ def evaluate_expression(expression):
             sub_exp = expression[start + 1 : end]
             sub_result = evaluate_simple_expression(sub_exp)
             expression = (
-                expression[:start] + "|".join(sub_result) + expression[end + 1 :]
+                expression[:start] + "&".join(sub_result) + expression[end + 1 :]
             )
         return evaluate_simple_expression(expression)
 

tests/nodes/base_node_test.py

@@ -0,0 +1,24 @@
+import pytest
+
+from scrapegraphai.nodes.base_node import BaseNode
+
+
+class DummyNode(BaseNode):
+    def execute(self, state):
+        return state
+
+
+@pytest.mark.parametrize(
+    "expression, expected",
+    [
+        ("a & (b & c)", ["a", "b", "c"]),
+        ("(a & b) & c", ["a", "b", "c"]),
+        ("(a & b) | c", ["a", "b"]),
+        ("a & (d | b)", ["a", "b"]),
+    ],
+)
+def test_get_input_keys_with_parentheses(expression, expected):
+    node = DummyNode("Dummy", "node", expression, ["out"])
+    state = {"a": 1, "b": 2, "c": 3}
+
+    assert node.get_input_keys(state) == expected

tests/utils/parse_state_keys_test.py

@@ -19,3 +19,12 @@ def test_parse_expression():
         assert result != []
     except ValueError as e:
         assert "Error" in str(e)
+
+
+def test_parse_expression_and_inside_parentheses():
+    """Every key of an AND group in parentheses is required and returned."""
+    state = {"a": None, "b": None, "c": None}
+
+    assert parse_expression("a & (b & c)", state) == ["a", "b", "c"]
+    assert parse_expression("(a & b) & c", state) == ["a", "b", "c"]
+    assert parse_expression("(a & b) | c", state) == ["a", "b"]