Python2 (with six) metaclass and Fields with parameters

Question

I am working on creating a metaclass that should work with fields.

Based on sources on the internet, and here on StackOverflow I have come this far:

Metaclass

def getmethod(attrname):
    def _getmethod(self):
        return getattr(self, "__"+attrname).get()
    return _getmethod


def setmethod(attrname):
    def _setmethod(self, value):
        return getattr(self, "__"+attrname).set(value)
    return _setmethod


class Metaclass(type):
    def __new__(cls, name, based, attrs):
        ndict = {}
        for attr in attrs:
            if isinstance(attrs[attr], Field):
                ndict['__'+attr] = attrs[attr]
                ndict[attr] = property(getmethod(attr), setmethod(attr))
        return super(Metaclass, cls).__new__(cls, name, based, ndict)

model

class Model(six.with_metaclass(Metaclass)):
    foo = CharField()

    def __init__(self, *args, **kwargs):
        pass

Field

class Field(object):
    def __init__(self, required=False, *args, **kwargs):
        self.required = required
        self.name = None

    def set(self, value):
        self.value = value

    def get(self):
        return self.value

    def set_name(self, name):
        self.name = name

CharField

class CharField(Field):
    def __init__(self, required=False, max_length=0, min_length=0, *args, **kwargs):
        self.max_length = max_length
        self.min_length = min_length
        super(CharField, self).__init__(required, args, kwargs)

Now when I create a subclass of Model

class Product(Model):
    name = CharField()

and create an instance of Product

if __name__ == '__main__':
    p = Product()

This works just fine.

I can even add or change the product name

if __name__ == '__main__':
    p = Product()
    p.name = "Another beautiful product"

However, when I would like to use name as a parameter:

if __name__ == '__main__':
    p = Product(name="Another beautiful product")

An error is raised: TypeError: object() takes no parameters

When debugging I can see that the instance of the Metaclass is created but the error is raised when the line return super(Metaclass, cls).__new__(cls, name, based, ndict) is reached.

Could someone help me out here?

Answer 1

In your code you create an interesting set of collaborative Field class, that can be made to work as rich, automatic properties. (* See bellow on that).

BUT your metaclass code only worries about the Field attributes, and does nothing to automate the parameters passed on class instantiation. When you write code like Product(name="my name") the "name='my name'" parameter is passed into the class's __init__ method and __new__ methods. Ordinarily Python special cases __init__ and __new__ so that parameters to __init__ when __new__ is not declared are not passed up to the baseclass (object). Probably the use of six.with_metaclass is breaking this mechanism - and your name is getting to object's contructor (and that triggers the error you are seeing).

You can fix that by customizing the __new__ (or __init__ if you can get away of the metaclass at all, see bellow)- Just consume your **kwargs parameters, setting whatever fields where sent, and call object's __new__ without those extraneous parameters:

class Model(object):
    def __init__(self, **kwargs):
         for key, value in kwargs.items():
              if isinstance(getattr(self.__class__, key, None), Field):
                  setattr(self, key, value)

(see bellow - if you still need a metaclass with "six", you will likely need to write this code in __new__, not in __init__)

(*) Now - beyond your main problem - since you need richer properties than the allowed by Python's property, you should not be using it - take a look on how the Descriptor Protocol works - basically, by creating your Field class defining methods named __get__ and __set__ you can have the additional functionality you want from your fields without the need for a metaclass at all (to that functionality - for the __init__ call to work automatically as you want, you still will need either to customize the base __init__ or a metaclass)