How to pass arguments to the metaclass from the class definition?

Question

I'm trying to dynamically generate classes in python 2.7, and am wondering if you can easily pass arguments to the metaclass from the class object.

I've read this post, which is awesome, but doesn't quite answer the question. at the moment I am doing:

def class_factory(args, to, meta_class):
    Class MyMetaClass(type):
        def __new__(cls, class_name, parents, attrs):
            attrs['args'] = args
            attrs['to'] = to
            attrs['eggs'] = meta_class

    class MyClass(object):
        metaclass = MyMetaClass
        ...

but this requires me to do the following

MyClassClass = class_factory('spam', 'and', 'eggs')
my_instance = MyClassClass()

Is there a cleaner way of doing this?

Answer 1

While the question is for Python 2.7 and already has an excellent answer, I had the same question for Python 3.3 and this thread was the closest thing to an answer I could find with Google. I found a better solution for Python 3.x by digging through the Python documentation, and I'm sharing my findings for anyone else coming here looking for a Python 3.x version.

Passing Arguments to the Metaclass in Python 3.x

After digging through Python's official documentation, I found that Python 3.x offers a native method of passing arguments to the metaclass, though not without its flaws.

Simply add additional keyword arguments to your class declaration:

class C(metaclass=MyMetaClass, myArg1=1, myArg2=2):
  pass

...and they get passed into your metaclass like so:

class MyMetaClass(type):

  @classmethod
  def __prepare__(metacls, name, bases, **kwargs):
    #kwargs = {"myArg1": 1, "myArg2": 2}
    return super().__prepare__(name, bases, **kwargs)

  def __new__(metacls, name, bases, namespace, **kwargs):
    #kwargs = {"myArg1": 1, "myArg2": 2}
    return super().__new__(metacls, name, bases, namespace)
    #DO NOT send "**kwargs" to "type.__new__".  It won't catch them and
    #you'll get a "TypeError: type() takes 1 or 3 arguments" exception.

  def __init__(cls, name, bases, namespace, myArg1=7, **kwargs):
    #myArg1 = 1  #Included as an example of capturing metaclass args as positional args.
    #kwargs = {"myArg2": 2}
    super().__init__(name, bases, namespace)
    #DO NOT send "**kwargs" to "type.__init__" in Python 3.5 and older.  You'll get a
    #"TypeError: type.__init__() takes no keyword arguments" exception.

You have to leave kwargs out of the call to type.__new__ and type.__init__ (Python 3.5 and older; see "UPDATE") or will get you a TypeError exception due to passing too many arguments. This means that--when passing in metaclass arguments in this manner--we always have to implement MyMetaClass.__new__ and MyMetaClass.__init__ to keep our custom keyword arguments from reaching the base class type.__new__ and type.__init__ methods. type.__prepare__ seems to handle the extra keyword arguments gracefully (hence why I pass them through in the example, just in case there's some functionality I don't know about that relies on **kwargs), so defining type.__prepare__ is optional.

UPDATE

In Python 3.6, it appears type was adjusted and type.__init__ can now handle extra keyword arguments gracefully. You'll still need to define type.__new__ (throws TypeError: __init_subclass__() takes no keyword arguments exception).

Breakdown

In Python 3, you specify a metaclass via keyword argument rather than class attribute:

class MyClass(metaclass=MyMetaClass):
  pass

This statement roughly translates to:

MyClass = metaclass(name, bases, **kwargs)

...where metaclass is the value for the "metaclass" argument you passed in, name is the string name of your class ('MyClass'), bases is any base classes you passed in (a zero-length tuple () in this case), and kwargs is any uncaptured keyword arguments (an empty dict {} in this case).

Breaking this down further, the statement roughly translates to:

namespace = metaclass.__prepare__(name, bases, **kwargs)  #`metaclass` passed implicitly since it's a class method.
MyClass = metaclass.__new__(metaclass, name, bases, namespace, **kwargs)
metaclass.__init__(MyClass, name, bases, namespace, **kwargs)

...where kwargs is always the dict of uncaptured keyword arguments we passed in to the class definition.

Breaking down the example I gave above:

class C(metaclass=MyMetaClass, myArg1=1, myArg2=2):
  pass

...roughly translates to:

namespace = MyMetaClass.__prepare__('C', (), myArg1=1, myArg2=2)
#namespace={'__module__': '__main__', '__qualname__': 'C'}
C = MyMetaClass.__new__(MyMetaClass, 'C', (), namespace, myArg1=1, myArg2=2)
MyMetaClass.__init__(C, 'C', (), namespace, myArg1=1, myArg2=2)

Most of this information came from Python's Documentation on "Customizing Class Creation".