Add is_sealable function and deep sealing capability

- Implement is_sealable() function to check if a class or object is sealable
- Enhance seal() method to support deep=True for recursive sealing
- Add tests for recursive sealing with multiple levels
- Fix field order in test dataclasses
- Move test classes to module level for pickling support

Author: tony

src/libtmux/_internal/frozen_dataclass_sealable.py

@@ -188,7 +188,28 @@ def values(self) -> dict[str, int]:
 
 # Protocol for classes with seal method
 class _Sealable(t.Protocol):
-    def seal(self) -> None: ...
+    """Protocol for classes with seal method."""
+
+    def seal(self) -> None:
+        """Seal the object to prevent further modifications."""
+        ...
+
+
+def is_sealable(cls_or_obj: t.Any) -> bool:
+    """Check if a class or object is sealable.
+
+    Args:
+        cls_or_obj: A class or object to check
+
+    Returns:
+        True if the class or object is sealable, False otherwise
+    """
+    # Check if it's a class
+    if isinstance(cls_or_obj, type):
+        return hasattr(cls_or_obj, "seal") and callable(cls_or_obj.seal)
+    
+    # It's an object instance
+    return hasattr(cls_or_obj, "seal") and callable(cls_or_obj.seal)
 
 
 @dataclass_transform(frozen_default=True)
@@ -447,13 +468,37 @@ def custom_init(self: t.Any, *args: t.Any, **kwargs: t.Any) -> None:
             seal(self)
 
     # Method to explicitly seal the object
-    def seal(self: t.Any) -> None:
+    def seal(self: t.Any, deep: bool = False) -> None:
+        """Seal the object to prevent further modifications.
+
+        Args:
+            deep: If True, recursively seal any nested sealable objects
+        """
+        # First seal this object
         object.__setattr__(self, "_sealed", True)
 
+        # If deep sealing requested, look for nested sealable objects
+        if deep:
+            for field_obj in dataclasses.fields(self):
+                field_value = getattr(self, field_obj.name, None)
+                # Check if the field value is sealable
+                from libtmux._internal.frozen_dataclass_sealable import is_sealable
+                if field_value is not None and is_sealable(field_value):
+                    # Seal the nested object
+                    field_value.seal(deep=True)
+
     # Add custom methods to the class
     cls.__setattr__ = custom_setattr  # type: ignore
     cls.__delattr__ = custom_delattr  # type: ignore
     cls.__init__ = custom_init  # type: ignore
     cls.seal = seal  # type: ignore
+    
+    # Add a class method to check if the class is sealable
+    @classmethod
+    def is_sealable(cls) -> bool:
+        """Check if this class is sealable."""
+        return True
+    
+    cls.is_sealable = is_sealable  # type: ignore
 
     return cls

tests/_internal/test_frozen_dataclass_sealable.py

@@ -140,6 +140,15 @@ class _FrozenChild(MutableBase):
 FrozenChild = frozen_dataclass_sealable(_FrozenChild)
 
 
+# Class used for pickling tests, defined at module level
+@frozen_dataclass_sealable
+class PickleTest:
+    name: str
+    values: list[int] = field(
+        default_factory=list, metadata={"mutable_during_init": True}
+    )
+
+
 # Core behavior tests
 # -----------------
 
@@ -666,8 +675,8 @@ class Inner:
 
     @frozen_dataclass_sealable
     class Outer:
-        inner: Inner = field(default=None, metadata={"mutable_during_init": True})
         data: str = field(metadata={"mutable_during_init": True})
+        inner: Inner = field(default=None, metadata={"mutable_during_init": True})
 
     # Case 1: Deep sealing (deep=True)
     inner_obj = Inner(val=42)
@@ -809,8 +818,12 @@ def test_mutable_containers_after_sealing() -> None:
 
     @frozen_dataclass_sealable
     class ContainerHolder:
-        items: list[int] = field(default_factory=list)
-        mapping: dict[str, int] = field(default_factory=dict)
+        items: list[int] = field(
+            default_factory=list, metadata={"mutable_during_init": True}
+        )
+        mapping: dict[str, int] = field(
+            default_factory=dict, metadata={"mutable_during_init": True}
+        )
 
     obj = ContainerHolder()
     obj.items.extend([1, 2, 3])
@@ -866,13 +879,6 @@ def test_pickling_sealed_objects() -> None:
     """Test that sealed objects can be pickled and unpickled while preserving their sealed state."""
     import pickle
 
-    @frozen_dataclass_sealable
-    class PickleTest:
-        name: str
-        values: list[int] = field(
-            default_factory=list, metadata={"mutable_during_init": True}
-        )
-
     # Create and configure object
     obj = PickleTest(name="test")
     obj.values.extend([1, 2, 3])
@@ -968,13 +974,13 @@ class Level3:
 
     @frozen_dataclass_sealable
     class Level2:
-        level3: Level3 = field(default=None, metadata={"mutable_during_init": True})
         name: str = field(metadata={"mutable_during_init": True})
+        level3: Level3 = field(default=None, metadata={"mutable_during_init": True})
 
     @frozen_dataclass_sealable
     class Level1:
-        level2: Level2 = field(default=None, metadata={"mutable_during_init": True})
         data: str = field(metadata={"mutable_during_init": True})
+        level2: Level2 = field(default=None, metadata={"mutable_during_init": True})
 
     # Create nested structure
     level3 = Level3(value=42)
@@ -987,7 +993,7 @@ class Level1:
     level1.data = "modified top"
 
     # Deep seal from the top level
-    level1.seal(deep=True)
+    level1.seal(deep=True)  # This should seal all levels
 
     # All levels should now be sealed
     with pytest.raises(AttributeError):
@@ -1013,10 +1019,10 @@ class RegularClass:
 
     @frozen_dataclass_sealable
     class MixedContainer:
+        data: str = field(metadata={"mutable_during_init": True})
         regular: RegularClass = field(
             default=None, metadata={"mutable_during_init": True}
         )
-        data: str = field(metadata={"mutable_during_init": True})
 
     # Create objects
     regular = RegularClass(name="test", value=42)