How decorators work with classes in python

Question

I've tried to understand how a certain singleton decorator implementation for a class works, but I only got confused.

Here's the code:

def singleton(cls):
    instance = None

    @functools.wraps(cls)
    def inner(*args, **kwargs):
        nonlocal instance
        if instance is None:
            instance = cls(*args, **kwargs)
        return instance
    return inner

@deco is a syntatic sugar for cls = deco(cls), so in this code, when we define our cls class and wrap it with this singleton decorator, cls won't be a class anymore, but a function. Python dynamically searches for what objects are variables are linked to, so then later we try to create an instance of our class, and this line of code runs instance = cls(*args, **kwargs), won't we go into an infinite recursion? cls is not a class at this moment, it's a function, so it should call itself, going into recursion.

But it works fine. A singletone is created and no recursions happen. How does it work?

Answer 1

The function inner is closed over the local variable cls.

cls is a reference to the class. It is never rebound to anything else.

The decorator returns a function that returns an instance, but this does not affect what the inner cls variable refers to

Answer 2

cls is a reference to the original class passed in to the decorator. It retains the value it had when the decorator was called. Its value is "trapped" in the function returned by the decorator; for obscure reasons, this is called a closure. Most languages in which functions are first-class objects have this capability.

Answer 3

def singleton(cls):
    instance = None

    @functools.wraps(cls)
    def inner(*args, **kwargs):
        nonlocal instance
        if instance is None:
            instance = cls(*args, **kwargs)
            print cls
        return instance
    return inner

@singleton
class TryMe(object):
   pass

m = TryMe()
print m

You will get:

<class '__main__.TryMe'>
<__main__.TryMe object at 0x10231c9d0>