feat: add &, |, getitem and getattr operators to BinaryNodeVisitor

dynamic_expressions/nodes.py

@@ -28,7 +28,7 @@ class BinaryExpressionNode(Node):
     right: Node
 
 
-@dataclass(slots=True, frozen=True, kw_only=True)
+@dataclass(slots=True, frozen=True)
 class LiteralNode(Node):
     value: Any
 

dynamic_expressions/types.py

@@ -26,4 +26,8 @@ class ExecutionContext:
     "/",
     "//",
     "^",
+    "&",
+    "|",
+    "getitem",
+    "getattr",
 ]

dynamic_expressions/visitors.py

@@ -1,6 +1,7 @@
 import abc
 import operator
 from collections.abc import Callable, Mapping
+from functools import reduce
 from typing import Any, ClassVar, Protocol
 
 from dynamic_expressions.nodes import (
@@ -61,9 +62,13 @@ async def visit(
         return True
 
 
+def _visit_getattr(value: Any, properties: Any) -> object:  # noqa: ANN401
+    return reduce(getattr, properties.split("."), value)
+
+
 class BinaryExpressionVisitor(Visitor[BinaryExpressionNode, EmptyContext]):
     operator_mapping: ClassVar[
-        Mapping[BinaryExpressionOperator, Callable[[Any, Any], bool]]
+        Mapping[BinaryExpressionOperator, Callable[[Any, Any], object]]
     ] = {
         "=": operator.eq,
         ">": operator.gt,
@@ -78,6 +83,10 @@ class BinaryExpressionVisitor(Visitor[BinaryExpressionNode, EmptyContext]):
         "/": operator.truediv,
         "//": operator.floordiv,
         "^": operator.pow,
+        "&": operator.and_,
+        "|": operator.or_,
+        "getitem": operator.getitem,
+        "getattr": _visit_getattr,
     }
 
     async def visit(
@@ -86,7 +95,7 @@ async def visit(
         node: BinaryExpressionNode,
         dispatch: Dispatch[EmptyContext],
         context: EmptyContext,
-    ) -> bool:
+    ) -> object:
         left = await dispatch(node.left, context)
         right = await dispatch(node.right, context)
 

tests/nodes/test_binary_node.py

@@ -34,3 +34,40 @@ async def test_eq(
 ) -> None:
     node = BinaryExpressionNode(operator="=", left=left, right=right)
     assert await dispatcher.visit(node, None) == (left.value == right.value)
+
+
+@pytest.mark.parametrize(
+    ("left", "right", "expected"),
+    [
+        (0, 63, 0),
+        (5, 4, 4),
+        (8, 4, 0),
+    ],
+)
+async def test_binary_and(
+    dispatcher: VisitorDispatcher[EmptyContext], left: int, right: int, expected: int
+) -> None:
+    node = BinaryExpressionNode(
+        operator="&", left=LiteralNode(left), right=LiteralNode(right)
+    )
+    assert await dispatcher.visit(node, None) == expected == (left & right)
+
+
+@pytest.mark.parametrize(
+    ("left", "right", "expected"),
+    [
+        (pytest, "mark", pytest.mark),
+        (pytest, "mark.parametrize", pytest.mark.parametrize),
+        (pytest, "mark.parametrize.markname", pytest.mark.parametrize.markname),
+    ],
+)
+async def test_getattr(
+    dispatcher: VisitorDispatcher[EmptyContext],
+    left: object,
+    right: str,
+    expected: object,
+) -> None:
+    node = BinaryExpressionNode(
+        operator="getattr", left=LiteralNode(left), right=LiteralNode(right)
+    )
+    assert await dispatcher.visit(node, None) == expected