event_listener_minimal

from __future__ import annotations

from collections.abc import Callable
from typing import TypeVar
from weakref import proxy, ref, WeakSet


T = TypeVar("T")


def weaken_closures(listener: Callable) -> Callable:
    if listener.__closure__ is None:
        return listener

    for cell in listener.__closure__:
        contents = cell.cell_contents
        cell.cell_contents = proxy(contents)

    return listener


class Event:

    def __init__(self, instance: T) -> None:
        self._instance = ref(instance)
        self.listeners: WeakSet[Callable] = WeakSet()

    def add_listener(self, listener: Callable) -> Callable:
        self.listeners.add(weaken_closures(listener))
        return listener

    def notify(self):
        for listener in self.listeners:
            listener()

class Bar:
    def __init__(self):
        self.Event = Event(self)

bar = Bar()

class Foo:

    def __init__(self):

        print("'self' before the closure:")
        print(self)
        print(type(self))

        @bar.Event.add_listener
        def baz():
            # This runs when Event is called
            print("'self' within the closure:")
            print(self)
            print(type(self))

        self.listeners = baz

        print("'self' after the closure:")
        print(self)
        print(type(self))

foo = Foo()

bar.Event.notify()