Simplify deepcopy fix to per-class overrides on And, Or, Not

Instead of a generic __deepcopy__ on BooleanExpression with Pydantic
internals, add simple __deepcopy__ methods to the three classes that
need them. Also add identity assertions for non-Singleton copies.

Author: robreeves

pyiceberg/expressions/__init__.py

@@ -52,13 +52,6 @@ def _to_literal(value: L | Literal[L]) -> Literal[L]:
 class BooleanExpression(IcebergBaseModel, ABC):
     """An expression that evaluates to a boolean."""
 
-    def __deepcopy__(self, memo: dict[int, Any]) -> BooleanExpression:
-        """Return a deep copy of this expression."""
-        if isinstance(self, Singleton):
-            return self
-        fields = {name: copy.deepcopy(getattr(self, name), memo) for name in type(self).model_fields}
-        return type(self)(**fields)
-
     @abstractmethod
     def __invert__(self) -> BooleanExpression:
         """Transform the Expression into its negated version."""
@@ -347,6 +340,10 @@ def __invert__(self) -> BooleanExpression:
         # De Morgan's law: not (A and B) = (not A) or (not B)
         return Or(~self.left, ~self.right)
 
+    def __deepcopy__(self, memo: dict[int, Any]) -> And:
+        """Return a deep copy of the And expression."""
+        return And(copy.deepcopy(self.left, memo), copy.deepcopy(self.right, memo))
+
     def __getnewargs__(self) -> tuple[BooleanExpression, BooleanExpression]:
         """Pickle the And class."""
         return (self.left, self.right)
@@ -394,6 +391,10 @@ def __invert__(self) -> BooleanExpression:
         # De Morgan's law: not (A or B) = (not A) and (not B)
         return And(~self.left, ~self.right)
 
+    def __deepcopy__(self, memo: dict[int, Any]) -> Or:
+        """Return a deep copy of the Or expression."""
+        return Or(copy.deepcopy(self.left, memo), copy.deepcopy(self.right, memo))
+
     def __getnewargs__(self) -> tuple[BooleanExpression, BooleanExpression]:
         """Pickle the Or class."""
         return (self.left, self.right)
@@ -436,6 +437,10 @@ def __invert__(self) -> BooleanExpression:
         """Transform the Expression into its negated version."""
         return self.child
 
+    def __deepcopy__(self, memo: dict[int, Any]) -> Not:
+        """Return a deep copy of the Not expression."""
+        return Not(copy.deepcopy(self.child, memo))
+
     def __getnewargs__(self) -> tuple[BooleanExpression]:
         """Pickle the Not class."""
         return (self.child,)

tests/expressions/test_expressions.py

@@ -1300,24 +1300,28 @@ def test_deepcopy_and() -> None:
     expr = And(EqualTo("x", 1), EqualTo("y", 2))
     copied = copy.deepcopy(expr)
     assert copied == expr
+    assert copied is not expr
 
 
 def test_deepcopy_or() -> None:
     expr = Or(EqualTo("x", 1), EqualTo("y", 2))
     copied = copy.deepcopy(expr)
     assert copied == expr
+    assert copied is not expr
 
 
 def test_deepcopy_not() -> None:
     expr = Not(EqualTo("x", 1))
     copied = copy.deepcopy(expr)
     assert copied == expr
+    assert copied is not expr
 
 
 def test_deepcopy_equal_to() -> None:
     expr = EqualTo("x", 1)
     copied = copy.deepcopy(expr)
     assert copied == expr
+    assert copied is not expr
 
 
 def test_deepcopy_always_true() -> None: