The difference is that inheriting from a class does not affect how the class is created, it only affects how instances of the class are created. If you do: class A(object): # stuff class B(A): # stuff then A does not have any opportunity to “hook in” when B is created. Methods of A may … Read more
The error message indicates that you have two conflicting metaclasses somewhere in your hierarchy. You need to examine each of your classes and the QT classes to figure out where the conflict is. Here’s some simple example code that sets up the same situation: class MetaA(type): pass class MetaB(type): pass class A: __metaclass__ = MetaA … Read more
Decorators are much, much simpler and more limited — and therefore should be preferred whenever the desired effect can be achieved with either a metaclass or a class decorator. Anything you can do with a class decorator, you can of course do with a custom metaclass (just apply the functionality of the “decorator function”, i.e., … Read more
In the current version of Python, the class ordering is preserved. See PEP520 for details. In older versions of the language (3.5 and below, but not 2.x), you can provide a metaclass which uses an OrderedDict for the class namespace. import collections class OrderedClassMembers(type): @classmethod def __prepare__(self, name, bases): return collections.OrderedDict() def __new__(self, name, bases, … Read more
You’re getting that exception because, despite its class-like name, threading.Condition is a function, and you cannot subclass functions. >>> type(threading.Condition) <type ‘function’> This not-very-helpful error message has been raised on the Python bugtracker, but it has been marked “won’t fix.”
It’s not a custom-metaclass problem (though it’s diagnosed at metaclass stage): >>> class Normal(object): pass … >>> class MyObject(object, Normal): pass … Traceback (most recent call last): File “<stdin>”, line 1, in <module> TypeError: Error when calling the metaclass bases Cannot create a consistent method resolution order (MRO) for bases object, Normal and the problem’s … Read more
If you want to alter the attributes dict before the class is created, or change the bases tuple, you have to use __new__. By the time __init__ sees the arguments, the class object already exists. Also, you have to use __new__ if you want to return something other than a newly created class of the … Read more
Yes, meta classes can do this. A meta class’ __new__ method returns the class, so just register that class before returning it. class MetaClass(type): def __new__(cls, clsname, bases, attrs): newclass = super(MetaClass, cls).__new__(cls, clsname, bases, attrs) register(newclass) # here is your register function return newclass class MyClass(object): __metaclass__ = MetaClass The previous example works in … Read more
You could use six.add_metaclass or six.with_metaclass: import abc, six @six.add_metaclass(abc.ABCMeta) class SomeAbstractClass(): @abc.abstractmethod def do_something(self): pass six is a Python 2 and 3 compatibility library. You can install it by running pip install six or by downloading the latest version of six.py to your project directory. For those of you who prefer future over six, … Read more
Both methods can be used to customize the result of the issubclass() built-in function. __subclasscheck__ class.__subclasscheck__(self, subclass) Return true if subclass should be considered a (direct or indirect) subclass of class. If defined, called to implement issubclass(subclass, class). Note that these methods are looked up on the type (metaclass) of a class. They cannot be … Read more