deepcopy does not respect metaclass

Question

I have a class which, by design, must follow the singleton pattern. So I went ahead and implemented it using a metaclass. Everything worked nicely until a bug was reported which, in summary, said that deepcopy-ied instances of my singleton class were not the same instances.

I can get around this bug by inheriting from a base singleton-type class, but I'd rather not, for reasons pointed out in this question.

A working example of this issue is presented below:

class SingletonMeta(type):
    def __init__(cls, name, bases, dict):
        super(SingletonMeta, cls).__init__(name, bases, dict)
        cls.instance = None 
    def __call__(cls,*args,**kw):
        print "SingletonMeta __call__ was called"
        if cls.instance is None:
            cls.instance = super(SingletonMeta, cls).__call__(*args, **kw)
        return cls.instance

class MyClass1(object):
    __metaclass__ = SingletonMeta

class SingletonBase(object):
    _instance = None
    def __new__(class_, *args, **kwargs):
        print "SingletonBase __new__ was called"
        if not isinstance(class_._instance, class_):
            class_._instance = object.__new__(class_, *args, **kwargs)
        return class_._instance

class MyClass2(SingletonBase):
  pass

from copy import deepcopy as dcp

mm1 = MyClass1()
mm2 = dcp(mm1)
print "mm1 is mm2:", mm1 is mm2

mb1 = MyClass2()
mb2 = dcp(mb1)
print "mb1 is mb2:", mb1 is mb2

Output:

SingletonMeta __call__ was called
mm1 is mm2: False
SingletonBase __new__ was called
SingletonBase __new__ was called
mb1 is mb2: True

Can you give me any pointers as to how should one resolve this issue? I'm running Python 2.7.X

score 3 · Accepted Answer · answered Mar 27 '12 at 10:26

The docs on the copy module say this:

In order for a class to define its own copy implementation, it can define special methods __copy__() and __deepcopy__(). [...] The latter is called to implement the deep copy operation; it is passed one argument, the memo dictionary. [...]

So if you declare these to return self, that ought to do the trick.

score 3 · Answer 2 · answered Mar 27 '12 at 10:38

3

When you need to customize class creation (not instance creation), you do it in the __new__ method of the metaclass:

def __new__(cls, name, bases, dict):
    dict['__deepcopy__'] = dict['__copy__'] = lambda self, *args: self
    return super(SingletonMeta, cls).__new__(cls, name, bases, dict)

and your test will give

SingletonMeta __call__ was called
mm1 is mm2: True

You need to define __copy__ as well or even shallow copies will result in new instances.

Glad that my solution in that thread came in handy.

answered Mar 27 '12 at 10:38

agf

171,228
44
289
238

The only problem with this solution (and with @AKX 's as well, since those two are equivalent) is that if the user of the `SingletonMeta` metaclass needs a custom implementation of `__deepcopy__`, it'll be overwritten (if I understand correctly). Is there no way around this? – Mar 27 '12 at 10:49
@dare2be Does it make sense to have a custom `__deepcopy__` on a singleton? A singleton means there should never be a copy. So `__deepcopy__` should always be the identity function. – agf Mar 27 '12 at 10:51
I guess you're right. And if one _does_ need a custom `__deepcopy__`, they shouldn't be using a singleton in the first place. Since yours and AKX's answers are pretty much the same, I'll choose AKX's for being "first". And for RTFM. :P Thank you all the same! – Mar 27 '12 at 10:56
@dare2be I assumed you knew how to customize `__copy__` and `__deepcopy__` behavior, but not how to do it inside a metaclass. – agf Mar 27 '12 at 11:00

deepcopy does not respect metaclass

2 Answers2

Linked