What are the life cycle rules on the reference to this object that the ref assigned to self.inst holds?

[edited for clarity]

Still not crystal clear, I think you ask about the life-cycle of cb.im_self?

In which case, the same life-cycle as if it weren't here, from the definition of a weakref, it doesn't affect the life-cycle of the object it holds, i.e. as soon as the object looses all non-weakref-references it will get destroyed and GC'ed.

from weakref import ref

class Foo(object):
    pass

def make_ref(var):
    print var # 1st print
    r = ref(var)
    print r # 2nd print
    return r

print make_ref(Foo()) # 3rd print

prints

<__main__.Foo object at 0x7f2600f06650>
<weakref at 0x7f2600ef2e68; to 'Foo' at 0x7f2600f06650>
<weakref at 0x7f2600ef2e68; dead>

because var looses scope as soon as the function ends and thus gets destroyed.

Even fuller example:

from weakref import ref

class Foo(object):
    pass

def say_goodbye(wr):
    print 'Goodbye!', wr

def make_ref(var):
    print var
    r = ref(var, say_goodbye)
    print r
    return r

print make_ref(Foo())
print 'Done'

prints

<__main__.Foo object at 0x7ffe2aef0610>
<weakref at 0x7ffe2aedce68; to 'Foo' at 0x7ffe2aef0610>
Goodbye! <weakref at 0x7ffe2aedce68; dead>
<weakref at 0x7ffe2aedce68; dead>
Done

I suspect that I am just being dense here. I am worried about the circular reference that the Proxy objects holds a (hard) ref to the weakref and the weakref holds a (I assume) hard ref back to the object. But I think that is ok as if the weakref dies the call-back will be be triggered and presumably released. However in the case where we lose all refs to the Proxy object, there is the 3 element cycle (proxy.inst -> ref -> proxy._destroy). But, again, I think that is the correct behaviour as if you register a call-back function you expect it to always run and keeping the proxy object around in probably the right move.

If I understand you correctly, by object you refer to CallbackRegistry. Proxy holds no hardrefs back to CallbackRegistry, you see in _BoundMethodProxy.add_callback() I used a _BoundMethodProxy, aka weakref back to CallbackRegistry, only level one recursion used here (as we don't add a callback to the callback's callback), so no worries.

In the case where we lose all hardrefs to the object held in the Proxy object, the 3 element-cycle will run, and callback to all the callbacks still there (I added the try except here to deal with that).

In the case where we loose all hardrefs to the proxy object itself, then nothing happens because nothing needs to happen, it has no hardrefs to it so it just gets GC'ed like any other object.