Fixed #10728 -- corrected subclassing of Fields who use the SubfieldBase...

    def __new__(cls, base, name, attrs):

        new_class = super(SubfieldBase, cls).__new__(cls, base, name, attrs)

        new_class.contribute_to_class = make_contrib(

                attrs.get('contribute_to_class'))

            new_class, attrs.get('contribute_to_class')

        )

        return new_class

class Creator(object):

    def __set__(self, obj, value):

        obj.__dict__[self.field.name] = self.field.to_python(value)

def make_contrib(func=None):

def make_contrib(superclass, func=None):

    """

    Returns a suitable contribute_to_class() method for the Field subclass.

        if func:

            func(self, cls, name)

        else:

            super(self.__class__, self).contribute_to_class(cls, name)

            super(superclass, self).contribute_to_class(cls, name)

        setattr(cls, self.name, Creator(self))

    return contribute_to_class

            return []

        raise TypeError('Invalid lookup type: %r' % lookup_type)

class SmallerField(SmallField):

    pass

class JSONField(models.TextField):

    __metaclass__ = models.SubfieldBase

from django.db import models

from django.utils.encoding import force_unicode

from fields import Small, SmallField, JSONField

from fields import Small, SmallField, SmallerField, JSONField

class MyModel(models.Model):

    def __unicode__(self):

        return force_unicode(self.name)

class OtherModel(models.Model):

    data = SmallerField()

class DataModel(models.Model):

    data = JSONField()

from django.test import TestCase

from fields import Small

from models import DataModel, MyModel

from models import DataModel, MyModel, OtherModel

class CustomField(TestCase):

            ],

            lambda m: str(m.data)

        )

    def test_field_subclassing(self):

        o = OtherModel.objects.create(data=Small("a", "b"))

        o = OtherModel.objects.get()

        self.assertEqual(o.data.first, "a")

        self.assertEqual(o.data.second, "b")