@functools.lru_cache on a nested function

So I have, essentially, this:

import functools
def do_stuff(foo, bar):
    @functools.lru_cache(maxsize=None)
    def cmp_form(word):
        return word.strip().casefold()
    cmp_form.cache_clear()
[...]
[... main contents of do_stuff function ...]

The situation is more complex and the calculation being cached is more expensive, but that's the nutshell version. It's worth caching the result because it's expensive to calculate and the same values are used over and over in a nested loop. But multiple calls to do_stuff don't necessarily share any data and there's no point in letting the cache grow boundlessly over a long run (though there's a good argument to letting it grow boundlessly over a single call to do_stuff, because many many results might have to be cached, and this is both meaningful and helpful during that single run).

What I'm wondering is whether the call to cmp_form.cache_clear() is necessary: is the cache cleared already each time do_stuff is called?

My suspicion is yes, because I expect that def is executable code, not a compiler macro, and that the decorator will be rebound each time the outer function is run, creating a new cache.

But I'm not sure that I'm right. Can anyone confirm or deny?