In the documentation for `weakref.finalize` (https://docs.python.org/3.9/library/weakref.html#weakref.finalize), it says:

"Note It is important to ensure that func, args and kwargs do not own any references to obj, either directly or indirectly, since otherwise obj will never be garbage collected. In particular, func should not be a bound method of obj."

However, at the bottom of the document, in the section called "Comparing finalizers with __del__() methods" (https://docs.python.org/3.8/library/weakref.html#comparing-finalizers-with-del-methods), the following code is part of an example of how to use `weakref.finalize`:

class TempDir:
    def __init__(self):
        self.name = tempfile.mkdtemp()
        self._finalizer = weakref.finalize(self, shutil.rmtree, self.name)

I believe this code violates the rule that func, args, and kwargs should not have a reference to obj. In the example, obj is the instance of TempDir, and one of the arguments to finalize's callback is an attribute of the same instance of TempDir.

I do not know how to fix this example code. I found it while trying to figure out how to use `weakref.finalize`.

Not a problem. Arguments to a function are evaluated before the function is invoked.  So in

self._finalizer = weakref.finalize(self, shutil.rmtree, self.name)

self.name is evaluated before weakref.finalize is called(). `self.name` _extracts_ the `.name` attribute of `self`, and the result is simply a pathname (returned by the earlier call to `mkdtemp()`), from which `self` cannot be accessed.

Just like, e.g., for just about any old object O, after

    O.name = 42

a later `O.name` extracts the int 42, with no trace of that 42 had anything to do with `O`.

This isn't so when for a bound method object: `O.method_name` constructs and returns an object that _does_ reference `O`. That's why the earlier docs highlight bound method objects. For an attribute `name` bound to a chunk of data, `O.name` just retrieves that data, which _generally_ has nothing to do with `O` beyond that it happens to be reachable from `O` (but also generally NOT the reverse).

Perfect, thanks for your quick response. I was passing a bound method of obj as the func to `weakref.finalize(obj, func, /, *args, **kwargs)`. It slipped my mind that an instance variable like self.name and a bound method like self.clean_up, though they both belong to self, would be evaluated differently.

For anyone wondering, I was looking for weakref.proxy (https://docs.python.org/3/library/weakref.html#weakref.proxy) or weakref.WeakMethod (https://docs.python.org/3/library/weakref.html#weakref.WeakMethod)