Added experiments

experiments/callableweakref-tests.py

@@ -0,0 +1,170 @@
+# Note 1: The expected behavior of weakref to an instance is that it should
+# return None if no other strong references to the instance exist,
+# signalling that the instance can be safely garbage collected.
+#
+# Note 2: The expected behavior of weakref to a method is that it should
+# return None if no other strong references to the parent instance exist,
+# signalling that the parent instance can be safely garbage collected.
+#
+# Note 3: The IPython interpreter stores its own references and will
+# produce results different from those of the default Python interpreter.
+import callableweakref
+import weakref
+import unittest
+
+
+class TestCallableWeakRef(unittest.TestCase):
+
+    def test_instanceDirectWeakref_dies_on_arrival(self):
+        'Assert that weakref works as expected'
+        instanceDirectWeakref = weakref.ref(Instance())
+        assert instanceDirectWeakref() is None
+
+    def test_instanceIndirectWeakref_dies_when_instance_dies(self):
+        'Assert that weakref works as expected'
+        instance = Instance()
+        instanceIndirectWeakref = weakref.ref(instance)
+        assert instanceIndirectWeakref() is instance
+        del instance
+        assert instanceIndirectWeakref() is None
+
+    def test_boundMethodDirectWeakref_dies_on_arrival(self):
+        'Assert that weakref does not work as expected'
+        instance = Instance()
+        boundMethodDirectWeakref = weakref.ref(instance.call)
+        assert boundMethodDirectWeakref() is None  # Should be instance
+
+    def test_boundMethodIndirectWeakref_lives_when_instance_dies(self):
+        'Assert that weakref works as expected'
+        instance = Instance()
+        boundMethod = instance.call
+        boundMethodIndirectWeakref = weakref.ref(boundMethod)
+        assert boundMethodIndirectWeakref() is boundMethod
+        del instance
+        assert boundMethodIndirectWeakref() is boundMethod
+        del boundMethod
+        assert boundMethodIndirectWeakref() is None
+
+    def test_unboundMethodDirectWeakref_dies_on_arrival(self):
+        'Assert that weakref does not work as expected'
+        unboundMethodDirectWeakref = weakref.ref(Instance.call)
+        assert unboundMethodDirectWeakref() is None  # Should be Instance.call
+
+    def test_unboundMethodIndirectWeakref_dies_when_unboundMethod_dies(self):
+        'Assert that weakref works as expected'
+        unboundMethod = Instance.call
+        unboundMethodIndirectWeakref = weakref.ref(unboundMethod)
+        assert unboundMethodIndirectWeakref() is unboundMethod
+        del unboundMethod
+        assert unboundMethodIndirectWeakref() is None
+
+    def test_classFunctionDirectWeakref_dies_on_arrival(self):
+        'Assert that weakref works as expected'
+        classFunctionDirectWeakref = weakref.ref(Instance())
+        assert classFunctionDirectWeakref() is None
+
+    def test_classFunctionIndirectWeakref_dies_when_classFunction_dies(self):
+        'Assert that weakref works as expected'
+        classFunction = Instance()
+        classFunctionIndirectWeakref = weakref.ref(classFunction)
+        assert classFunctionIndirectWeakref() is classFunction
+        del classFunction
+        assert classFunctionIndirectWeakref() is None
+
+    def test_normalFunctionDirectWeakref_dies_when_normal_function_dies(self):
+        'Assert that weakref works as expected'
+        call = lambda: None
+        normalFunctionDirectWeakref = weakref.ref(call)
+        assert normalFunctionDirectWeakref() is call
+        del call
+        assert normalFunctionDirectWeakref() is None
+
+    def test_normalFunctionIndirectWeakref_dies_when_normal_function_dies(self):
+        'Assert that weakref works as expected'
+        call = lambda: None
+        normalFunction = call
+        normalFunctionIndirectWeakref = weakref.ref(normalFunction)
+        assert normalFunctionIndirectWeakref() is normalFunction
+        del normalFunction
+        assert normalFunctionIndirectWeakref() is call
+        del call
+        assert normalFunctionIndirectWeakref() is None
+
+    # Assert that CallableWeakref works as expected for callables
+
+    def test_boundMethodDirectCallableWeakref_dies_when_instance_dies(self):
+        instance = Instance()
+        boundMethodDirectCallableWeakref = callableweakref.ref(instance.call)
+        self.assertEqual(boundMethodDirectCallableWeakref(), instance.call)
+        del instance
+        assert boundMethodDirectCallableWeakref() is None
+
+    def test_boundMethodIndirectCallableWeakref_dies_when_instance_dies(self):
+        instance = Instance()
+        boundMethod = instance.call
+        boundMethodIndirectCallableWeakref = callableweakref.ref(boundMethod)
+        self.assertEqual(boundMethodIndirectCallableWeakref(), boundMethod)
+        del instance
+        self.assertEqual(boundMethodIndirectCallableWeakref(), boundMethod)
+        del boundMethod
+        assert boundMethodIndirectCallableWeakref() is None
+
+    def test_unboundMethodDirectCallableWeakref_lives_on_arrival(self):
+        unboundMethodDirectCallableWeakref = callableweakref.ref(Instance.call)
+        self.assertEqual(unboundMethodDirectCallableWeakref(), Instance.call)
+
+    def test_unboundMethodIndirectCallableWeakref_lives_on_arrival(self):
+        unboundMethod = Instance.call
+        unboundMethodIndirectCallableWeakref = callableweakref.ref(unboundMethod)
+        self.assertEqual(unboundMethodIndirectCallableWeakref(), unboundMethod)
+
+    def test_classMethodIndirectCallableWeakref_lives_on_arrival(self):
+        classMethod = Instance.call_classmethod
+        classMethodIndirectCallableWeakref = callableweakref.ref(classMethod)
+        self.assertEqual(classMethodIndirectCallableWeakref(), classMethod)
+
+    def test_staticMethodIndirectCallableWeakref_lives_on_arrival(self):
+        staticMethod = Instance.call_staticmethod
+        staticMethodIndirectCallableWeakref = callableweakref.ref(staticMethod)
+        self.assertEqual(staticMethodIndirectCallableWeakref(), staticMethod)
+
+    def test_classFunctionDirectCallableWeakref_dies_on_arrival(self):
+        classFunctionDirectCallableWeakref = callableweakref.ref(Instance())
+        assert classFunctionDirectCallableWeakref() is None
+
+    def test_classFunctionIndirectCallableWeakref_dies_when_classFunction_dies(self):
+        classFunction = Instance()
+        classFunctionIndirectCallableWeakref = callableweakref.ref(classFunction)
+        self.assertEqual(classFunctionIndirectCallableWeakref(), classFunction.__call__)
+        del classFunction
+        assert classFunctionIndirectCallableWeakref() is None
+
+    def test_normalFunctionDirectCallableWeakref_lives_on_arrival(self):
+        call = lambda: None
+        normalFunctionDirectCallableWeakref = callableweakref.ref(call)
+        self.assertEqual(normalFunctionDirectCallableWeakref(), call)
+
+    def test_normalFunctionIndirectCallableWeakref_lives_on_arrival(self):
+        call = lambda: None
+        normalFunction = call
+        normalFunctionIndirectWeakref = callableweakref.ref(normalFunction)
+        self.assertEqual(normalFunctionIndirectWeakref(), normalFunction)
+        del normalFunction
+        self.assertEqual(normalFunctionIndirectWeakref(), call)
+
+
+class Instance(object):
+
+    def __call__(self):
+        pass
+
+    def call(self):
+        pass
+
+    @classmethod
+    def call_classmethod(Class):
+        pass
+
+    @staticmethod
+    def call_staticmethod():
+        pass

experiments/callableweakref.py

@@ -0,0 +1,52 @@
+import types
+import weakref
+
+
+def ref(function):
+    return CallableWeakReference(function)
+
+
+class CallableWeakReference(object):
+
+    def __init__(self, function):
+        'Create a weak reference to a callable'
+        try:
+            if function.im_self:
+                # We have a bound method or class method
+                self._reference = weakref.ref(function.im_self)
+            else:
+                # We have an unbound method
+                self._reference = None
+            self._function = function.im_func
+            self._class = function.im_class
+        except AttributeError:
+            try:
+                function.func_code
+                # We have a normal function or static method
+                self._reference = None
+                self._function = function
+                self._class = None
+            except AttributeError:
+                function = function.__call__
+                # We have a class masquerading as a function
+                self._reference = weakref.ref(function.im_self)
+                self._function = function.im_func
+                self._class = function.im_class
+
+    def __call__(self):
+        if self.dead:
+            return
+        if self._reference:
+            # We have a bound method
+            return types.MethodType(self._function, self._reference(), self._class)
+        elif self._class:
+            return types.MethodType(self._function, None, self._class)
+        else:
+            return self._function
+
+    @property
+    def dead(self):
+        if self._reference and not self._reference():
+            # We have a bound method whose parent reference has died
+            return True
+        return False

experiments/t0.py

@@ -0,0 +1,6 @@
+from socketIO_client import SocketIO
+
+s = SocketIO('localhost', 8000)
+del s
+from time import sleep
+sleep(3)

experiments/t1.py

@@ -0,0 +1,7 @@
+class O(object):
+
+    def __del__(self):
+        print '__del__()'
+
+
+o = O()

experiments/t10.py

@@ -0,0 +1,16 @@
+class A(object):
+
+    def __init__(self):
+        self.b = B(self)
+
+    def __del__(self):
+        print '__del__()'
+
+
+class B(object):
+
+    def __init__(self, a):
+        self.a = a
+
+
+a = A()

experiments/t11.py

@@ -0,0 +1,21 @@
+class A(object):
+
+    def __init__(self):
+        self.c = Common()
+        self.b = B(self.c)
+
+    def __del__(self):
+        print '__del__()'
+
+
+class B(object):
+
+    def __init__(self, c):
+        self.c = c
+
+
+class Common(object):
+    pass
+
+
+a = A()

experiments/t12.py

@@ -0,0 +1,32 @@
+# Will the destructor of a class be called if its two children have cyclic
+# references to each other?  Yes.
+
+
+class Parent(object):
+
+    def __init__(self):
+        self.child = Child()
+
+    def __del__(self):
+        print 'Parent.__del__()'
+
+
+class Child(object):
+
+    def __init__(self):
+        self.grandChild = GrandChild(self)
+
+    def __del__(self):
+        print 'Child.__del__()'
+
+
+class GrandChild(object):
+
+    def __init__(self, parent):
+        self.parent = parent
+
+    def __del__(self):
+        print 'GrandChild.__del__()'
+
+
+parent = Parent()

experiments/t2.py

@@ -0,0 +1,19 @@
+import weakref
+
+
+class O(object):
+
+    def __init__(self):
+        self.p = P(self)
+
+    def __del__(self):
+        print '__del__()'
+
+
+class P(object):
+
+    def __init__(self, parent):
+        self.parent = weakref.ref(parent)
+
+
+o = O()

experiments/t3.py

@@ -0,0 +1,19 @@
+class O(object):
+
+    def __init__(self):
+        self.p = P(self.f)
+
+    def __del__(self):
+        print '__del__()'
+
+    def f(self):
+        pass
+
+
+class P(object):
+
+    def __init__(self, parentMethod):
+        self.parentMethod = parentMethod
+
+
+o = O()

experiments/t4.py

@@ -0,0 +1,26 @@
+import weakref
+
+
+class O(object):
+
+    def __init__(self):
+        self.p = P(self.f)
+
+    def __del__(self):
+        print '__del__()'
+
+    def f(self):
+        pass
+
+
+class P(object):
+
+    def __init__(self, parentMethod):
+        self.parentMethod = weakref.ref(parentMethod)
+
+    def show(self):
+        print self.parentMethod
+
+
+o = O()
+o.p.show()  # Dead on arrival

experiments/t5.py

@@ -0,0 +1,30 @@
+import callableweakref
+
+
+class O(object):
+
+    def __init__(self):
+        self.p = P(self.f)
+
+    def __del__(self):
+        print '__del__()'
+
+    def f(self):
+        print 'f()'
+
+
+class P(object):
+
+    def __init__(self, parentMethod):
+        self.parentMethod = callableweakref.ref(parentMethod)
+
+    def show(self):
+        print self.parentMethod
+
+    def run(self):
+        self.parentMethod()()
+
+
+o = O()
+o.p.show()
+o.p.run()