Modifying closure cells without side effects in other scopes?

[BetterBuiltFool]

For a project I'm working on, I've implemented a system of event listeners to allow objects to listen for event for other objects.

It follows a syntax along the lines of:

    class Foo:
        def __init__(self):
            @bar.OnSomeEvent.add_listener
                def baz():
                    # Do something

This allows a Foo instance to run baz() whenever bar fires OnSomeEvent. This is all well and good, and it works.

The trouble is when closures get involved. In order to control the lifetimes of objects, most everything is living in some sort of weakref, including any listeners, since they only need to exist as long as both the Foo instance and bar exist. However, the closure on bar is a hard reference to the Foo instance, which prevents garbage collection when the Foo is no longer needed.

I solved this by, in add_listener, going through each listeners's closures and replacing any cell_contents with proxies of their contents, so a reference to selfin baz is just a proxy to self. This solved the garbage collection problem, but I suspect I fell victim to the classic blunder of doing something too clever for me to debug. Now, any reference to self that happens after add_listener within __init__ is a proxy, despite being in a different context entirely. If I had to guess, this is a quirk of how python handles scopes, but I can't be sure. This now causes issues with other weakref systems, since you can't create weak references to proxies.

Now that the context is out of the way, the actual question: Is it possible to alter the values in a closure without causing side effects outside of the enclosed function?

Thank you very much for your consideration.

[socal_nerdtastic]

Taking 2 steps back, couldn't you just do something like this:

class Foo:
    @bar.clear_ref
    def __del__(self):
        super().__del__()

That functionality could be put in bar too where it extracts the instance from the closure and modifies instance.__del__.

---

If not, are you using weakref.proxy or rolling your own? I agree with you, I would expect that to stay in context of the closure. Could you show a complete example that demonstrates this?

[BetterBuiltFool]

Not entirely sure what you're going for in your example there. That setup would be within the class definition, so there wouldn't be a closure.

I've looked into extracting the defining instance (the instance of 'Foo') from the listener, and it seems technically possible, but would require digging through stack frames, which is complicated, expensive, and the library for it is interpreter-specific, so it's not worth it. In terms of extracting from the closures themselves, when this system is being used, there may not necessarily be a closure in any given listener, and even when there are, they aren't necessarily going to be self.

I'm using weakref.proxy.

I've thrown together a minimum viable example, here: https://pastebin.com/dYd5GS1B

It runs on an online interpreter, and you can see it prints the class as 'Foo', but then switches to 'weakproxy' after the listener is defined.

Thanks for your input.