fix bug with wrappers

Before, we replaced the class of a wrapper after its creation.
This turned out the be problematic with the GC in python 3.13.

Author: skogsbaer

python/deps/untypy/test/impl/test_simple.py

@@ -59,6 +59,7 @@ def test_attributes(self):
         def m(x: A) -> None:
             self.assertEqual(x.foo, 42)
             x.foo = 43
+            self.assertEqual(x.foo, 43)
 
         m(a)
         self.assertEqual(a.foo, 43)

python/deps/untypy/untypy/util/wrapper.py

@@ -3,42 +3,12 @@
 import collections
 from untypy.error import UntypyError
 from untypy.util.debug import debug
+import types
 
 def _f():
     yield 0
 generatorType = type(_f())
 
-class WyppWrapError(Exception):
-    pass
-
-def _readonly(self, *args, **kwargs):
-    raise RuntimeError("Cannot modify ReadOnlyDict")
-
-class ReadOnlyDict(dict):
-    __setitem__ = _readonly
-    __delitem__ = _readonly
-    pop = _readonly
-    popitem = _readonly
-    clear = _readonly
-    update = _readonly
-    setdefault = _readonly
-
-def patch(self, ty, extra):
-    # SW (2024-10-18): With python 3.13 there is the behavior that extra is modified after patching
-    # the object. I never found out who is doing the modification. By wrapping extra with
-    # ReadOnlyDict, everything works. Strangely, no error occurs somewhere.
-    self.__extra__ = ReadOnlyDict(extra)
-    w = self.__wrapped__
-    m = None
-    if hasattr(w, '__module__'):
-        m = getattr(w, '__module__')
-    ty.__module__ = m
-    try:
-        self.__class__ = ty
-    except TypeError as e:
-        raise WyppWrapError(f'Cannot wrap {self.__wrapped__} of type {type(self.__wrapped__)} ' \
-            f'at type {ty}. Original error: {e}')
-
 class WrapperBase:
     def __eq__(self, other):
         if hasattr(other, '__wrapped__'):
@@ -58,8 +28,6 @@ def __patch__(self, ms, name=None, extra=None):
         ty = type(name, (cls,), ms)
         patch(self, ty, extra)
     def __repr__(self):
-        #w = self.__wrapped__
-        #return f"Wrapper(addr=0x{id(self):09x}, wrapped_addr=0x{id(w):09x}, wrapped={repr(w)}"
         return repr(self.__wrapped__)
     def __str__(self):
         return str(self.__wrapped__)
@@ -72,27 +40,6 @@ def __reduce__(self): return self.__wrapped__.__reduce__()
     def __reduce_ex__(self): return self.__wrapped__.__reduce_ex__()
     def __sizeof__(self): return self.__wrapped__.__sizeof__()
 
-class ObjectWrapper(WrapperBase):
-    def __init__(self, baseObject):
-        self.__dict__ = baseObject.__dict__
-        self.__wrapped__ = baseObject
-    def __patch__(self, ms, name=None, extra=None):
-        if extra is None:
-            extra = {}
-        cls = self.__class__
-        if name is None:
-            name = cls.__name__
-        wrappedCls = type(self.__wrapped__)
-        ty = type(name, (wrappedCls, cls), ms)
-        patch(self, ty, extra)
-
-class ABCObjectWrapper(abc.ABC, ObjectWrapper):
-    pass
-
-# Superclasses in reverse order.
-class ABCObjectWrapperRev(ObjectWrapper, abc.ABC):
-    pass
-
 # A wrapper for list such that the class is a subclass of the builtin list class.
 class ListWrapper(WrapperBase, list): # important: inherit from WrapperBase first
     def __new__(cls, content):
@@ -224,33 +171,43 @@ def __new__(cls, content):
         self.__wrapped__ = content
         return self
 
-# These methods are not delegated to the wrapped object
-_blacklist = [
-    '__class__', '__delattr__', '__dict__', '__dir__', '__doc__',
-    '__getattribute__', '__get_attr_', '__init_subclass__'
-    '__init__', '__new__', '__del__', '__repr__', '__setattr__', '__str__',
-    '__hash__', '__eq__', '__patch__',
-    '__class_getitem__',  '__subclasshook__',
-    '__firstlineno__', '__static_attributes__']
+class WyppWrapError(Exception):
+    pass
+
+def _readonly(self, *args, **kwargs):
+    raise RuntimeError("Cannot modify ReadOnlyDict")
 
-_extra = ['__next__']
+class ReadOnlyDict(dict):
+    __setitem__ = _readonly
+    __delitem__ = _readonly
+    pop = _readonly
+    popitem = _readonly
+    clear = _readonly
+    update = _readonly
+    setdefault = _readonly
+
+def patch(self, ty, extra):
+    # SW (2024-10-18): With python 3.13 there is the behavior that extra is modified after patching
+    # the object. I never found out who is doing the modification. By wrapping extra with
+    # ReadOnlyDict, everything works. Strangely, no error occurs somewhere.
+    self.__extra__ = ReadOnlyDict(extra)
+    w = self.__wrapped__
+    m = None
+    if hasattr(w, '__module__'):
+        m = getattr(w, '__module__')
+    ty.__module__ = m
+    try:
+        self.__class__ = ty
+    except TypeError as e:
+        raise WyppWrapError(f'Cannot wrap {self.__wrapped__} of type {type(self.__wrapped__)} ' \
+            f'at type {ty}. Original error: {e}')
 
 # SimpleWrapper is a fallback for types that cannot be used as base types
 class SimpleWrapper(WrapperBase):
-    def __init__(self, baseObject):
-        self.__wrapped__ = baseObject
+    def __init__(self):
+        pass
     def __patch__(self, ms, name=None, extra=None):
-        if extra is None:
-            extra = {}
-        cls = self.__class__
-        if name is None:
-            name = cls.__name__
-        baseObject = self.__wrapped__
-        for x in dir(baseObject) + _extra:
-            if x not in ms and x not in _blacklist and hasattr(baseObject, x):
-                ms[x] = getattr(baseObject, x)
-        ty = type(name, (cls,), ms) #
-        patch(self, ty, extra)
+        pass
 
 class ValuesViewWrapper(SimpleWrapper):
     pass
@@ -264,46 +221,99 @@ class KeysViewWrapper(SimpleWrapper):
     pass
 collections.abc.KeysView.register(KeysViewWrapper)
 
+def wrapSimple(wrapped, methods, name, extra, cls=SimpleWrapper):
+    if name is None:
+        name = cls.__name__
+    if extra is None:
+        extra = {}
+    for x in ['__next__', '__iter__']:
+        if x not in methods and hasattr(wrapped, x):
+            attr = getattr(wrapped, x)
+            methods[x] = attr
+    # Dynamically create a new class:
+    # type(class_name, base_classes, class_dict)
+    WrapperClass = type(
+        name,
+        (cls,),
+        methods
+    )
+    if not name.startswith('WyppTypeCheck()') and hasattr(wrapped, '__module__'):
+        WrapperClass.__module__ = getattr(wrapped, '__module__')
+    w = WrapperClass()
+    w.__wrapped__ = wrapped
+    w.__extra__ = extra
+    return w
+
+def wrapObj(wrapped, methods, name, extra):
+    class BaseWrapper(WrapperBase, wrapped.__class__):
+        def __init__(self):
+            self.__dict__ = wrapped.__dict__
+            self.__wrapped__ = wrapped
+        def __patch__(self, ms, name=None, extra=None):
+            pass
+    if name is None:
+        name = 'ObjectWrapper'
+    if extra is None:
+        extra = {}
+    # Dynamically create a new class:
+    # type(class_name, base_classes, class_dict)
+    WrapperClass = type(
+        name,
+        (BaseWrapper,),
+        methods
+    )
+    if hasattr(wrapped, '__module__'):
+        WrapperClass.__module__ = getattr(wrapped, '__module__')
+    w = WrapperClass()
+    w.__extra__ = extra
+    return w
+
 def wrap(obj, methods, name=None, extra=None, simple=False):
     if extra is None:
         extra = {}
+    wrapper = None
     if simple:
-        w = SimpleWrapper(obj)
+        w = wrapSimple(obj, methods, name, extra)
+        wrapper = 'SimpleWrapper'
     elif isinstance(obj, list):
         w = ListWrapper(obj)
+        wrapper = 'ListWrapper'
     elif isinstance(obj, tuple):
         w = TupleWrapper(obj)
+        wrapper = 'TupleWrapper'
     elif isinstance(obj, dict):
         w = DictWrapper(obj)
+        wrapper = 'DictWrapper'
     elif isinstance(obj, str):
         w = StringWrapper(obj)
+        wrapper = 'StringWrapper'
     elif isinstance(obj, set):
         w = SetWrapper(obj)
+        wrapper = 'SetWrapper'
     elif isinstance(obj, collections.abc.ValuesView):
-        w = ValuesViewWrapper(obj)
+        w = wrapSimple(obj, methods, name, extra, ValuesViewWrapper)
+        wrapper = 'ValuesViewWrapper'
     elif isinstance(obj, collections.abc.KeysView):
-        w = KeysViewWrapper(obj)
+        w = wrapSimple(obj, methods, name, extra, KeysViewWrapper)
+        wrapper = 'KeysViewWrapper'
     elif isinstance(obj, collections.abc.ItemsView):
-        w = ItemsViewWrapper(obj)
+        w = wrapSimple(obj, methods, name, extra, ItemsViewWrapper)
+        wrapper = 'ItemsViewWrapper'
     elif isinstance(obj, typing.Generic):
-        w = SimpleWrapper(obj)
+        w = wrapSimple(obj, methods, name, extra)
+        wrapper = 'SimpleWrapper'
     elif isinstance(obj, generatorType):
-        w = SimpleWrapper(obj)
-    elif isinstance(obj, abc.ABC) and hasattr(obj, '__dict__'):
-        try:
-            w = ABCObjectWrapper(obj)
-        except WyppWrapError:
-            try:
-                w = ABCObjectWrapperRev(obj)
-            except WyppWrapError:
-                w = SimpleWrapper(obj)
+        w = wrapSimple(obj, methods, name, extra)
+        wrapper = 'SimpleWrapper'
     elif hasattr(obj, '__dict__'):
-        w = ObjectWrapper(obj)
+        w = wrapObj(obj, methods, name, extra)
+        wrapper = 'ObjectWrapper'
     else:
-        w = SimpleWrapper(obj)
+        w = wrapSimple(obj, methods, name, extra)
+        wrapper = 'SimpleWrapper'
     w.__patch__(methods, name, extra)
     wname = name
     if wname is None:
         wname = str(type(w))
-    debug(f"Wrapping {obj} at 0x{id(obj):09x} as {wname}, simple={simple}, wrapper=0x{id(w):09x}")
+    debug(f"Wrapping {obj} at 0x{id(obj):09x} as {wname}, simple={simple}, wrapper=0x{id(w):09x} ({wrapper})")
     return w

python/fileTests

@@ -289,6 +289,8 @@ checkWithOutputAux yes 0 test-data/testForwardTypeInRecord.py
 checkWithOutputAux yes 0 test-data/testForwardTypeInRecord2.py
 checkWithOutputAux yes 0 test-data/testUnionOfUnion.py
 checkWithOutputAux yes 1 test-data/testRecordTypes.py
+checkWithOutputAux yes 0 test-data/testDisappearingObject_01.py
+checkWithOutputAux yes 0 test-data/testDisappearingObject_02.py
 
 function is_min_version()
 {

python/run

@@ -1,10 +1,11 @@
 #!/bin/bash
 
+PY=python3.13 
 SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
 
 OPTS="--quiet"
 # OPTS="--verbose"
 
-PYTHONPATH="$SCRIPT_DIR"/site-lib:"$PYTHONPATH" python3 "$SCRIPT_DIR"/src/runYourProgram.py \
+PYTHONPATH="$SCRIPT_DIR"/site-lib:"$PYTHONPATH" $PY "$SCRIPT_DIR"/src/runYourProgram.py \
     --no-clear $OPTS "$@"
 exit $?

python/test-data/testDisappearingObject_01.err

@@ -0,0 +1,2 @@
+['subdir']
+Directory('stefan')

python/test-data/testDisappearingObject_01.out

@@ -0,0 +1,77 @@
+# This test comes from a bug reported by a student, 2025-05-8
+from __future__ import annotations
+from wypp import *
+import gc
+
+class FileSystemEntry:
+    def __init__(self, name: str):
+        self.name = name
+    def getName(self) -> str:
+        return self.name
+    def getContent(self) -> str:
+        raise Exception('No content')
+    def getChildren(self) -> list[FileSystemEntry]:
+        return []
+    def findChild(self, name: str) -> FileSystemEntry:
+        for c in self.getChildren():
+            if c.getName() == name:
+                return c
+        raise Exception('No child with name ' + name)
+    def addChild(self, child: FileSystemEntry) -> None:
+        raise Exception('Cannot add child to ' + repr(self))
+
+class Directory(FileSystemEntry):
+    def __init__(self, name: str, children: list[FileSystemEntry] = []):
+        super().__init__(name)
+        self.__children = children
+    def getChildren(self) -> list[FileSystemEntry]:
+        return self.__children
+    def addChild(self, child: FileSystemEntry):
+        self.__children.append(child)
+    def __repr__(self):
+        return 'Directory(' + repr(self.getName()) + ')'
+
+class File:
+    def __init__(self, name: str, content: str):
+        raise ValueError()
+        super().__init__(name)
+        self.content = content
+    def getContent(self) -> str:
+        return self.content
+
+class Link(FileSystemEntry):
+    def __init__(self, name: str, linkTarget: FileSystemEntry):
+        super().__init__(name)
+        self.__linkTarget = linkTarget
+    def getChildren(self) -> list[FileSystemEntry]:
+        return self.__linkTarget.getChildren()
+    def getContent(self) -> str:
+        return self.__linkTarget.getContent()
+    def addChild(self, child: FileSystemEntry):
+        self.__linkTarget.addChild(child)
+    def __repr__(self):
+        return ('Link(' + repr(self.getName()) + ' -> ' +
+                repr(self.__linkTarget) + ')')
+    def getLinkTarget(self) -> FileSystemEntry:
+        return self.__linkTarget
+
+class CryptoFile:
+    def __init__(self, name: str, content: str):
+        raise ValueError()
+        super().__init__(name)
+        self.content = content
+    def getContent(self) -> str:
+        return 'CRYPTO_' + 'X'*len(self.content)
+    def __repr__(self):
+        return 'CryptoFile(' + repr(self.getName())
+
+def test_link():
+    stefan  = Directory('stefan', [])
+    wehr    = Link('wehr', stefan)
+    l1 = [x.getName() for x in wehr.getChildren()]
+    wehr.addChild(Directory('subdir', []))
+    l2 = [x.getName() for x in wehr.getChildren()]
+    print(l2)
+    print(stefan)
+
+test_link()