Python rest_framework.serializers 模块，ModelSerializer() 实例源码

def setUp(self):
        from .models import User
        depends = self._getTarget()

        class ForDependsTestUserSerializer(serializers.ModelSerializer):
            class Meta:
                model = User
                fields = ('id', 'first_name', "last_name")

            first_name = serializers.SerializerMethodField()
            last_name = serializers.SerializerMethodField()

            @depends("username")
            def get_first_name(self, ob):
                return ob.username.split(" ", 1)[0]

            @depends("username")
            def get_last_name(self, ob):
                return ob.username.split(" ", 1)[1]
        self.Serializer = ForDependsTestUserSerializer

def _get_name(self):
        """
        :return: Serializer name
        :rtype: str
        """
        serializer = self.serializer

        if inspect.isclass(serializer):
            name = serializer.__name__
        else:
            name = serializer.__class__.__name__

        if name == 'DefaultSerializer' and issubclass(serializer, ModelSerializer):
            model_name = self.serializer.Meta.model.__name__
            name = '{0}Serializer'.format(model_name.strip())
        return name

def test_override(self):
        from biohub.utils.rest.serializers import bind_model, get_by_model
        from rest_framework.serializers import ModelSerializer
        from tests.utils.rest.models import TestModel

        @bind_model(TestModel, can_override=True)
        class SerializerA(ModelSerializer):

            class Meta:
                model = TestModel

        @bind_model(TestModel)
        class SerializerB(ModelSerializer):

            class Meta:
                model = TestModel

        self.assertIs(get_by_model(TestModel), SerializerB)

def test_bind(self):
        from biohub.utils.rest.serializers import bind_model, get_by_model
        from rest_framework.serializers import ModelSerializer
        from tests.utils.rest.models import TestModel

        @bind_model(TestModel)
        class TestModelSerializer(ModelSerializer):

            class Meta:
                model = TestModel

        self.assertIs(
            get_by_model(TestModel),
            TestModelSerializer
        )

        with self.assertRaises(KeyError) as cm:
            @bind_model(TestModel)
            class AnotherTestSerializer(ModelSerializer):

                class Meta:
                    model = TestModel

        self.assertIn('bound', str(cm.exception))

def get_serializer_class(configuration_model):
    """ Returns a ConfigurationModel serializer class for the supplied configuration_model. """
    class AutoConfigModelSerializer(ModelSerializer):
        """Serializer class for configuration models."""

        class Meta(object):
            """Meta information for AutoConfigModelSerializer."""
            model = configuration_model
            fields = '__all__'

        def create(self, validated_data):
            if "changed_by_username" in self.context:
                validated_data['changed_by'] = User.objects.get(username=self.context["changed_by_username"])
            return super(AutoConfigModelSerializer, self).create(validated_data)

    return AutoConfigModelSerializer

def setUp(self):
        from .models import User, Skill

        class AnotherSkillSerializer(serializers.ModelSerializer):
            fullname = serializers.CharField(source="name")

            class Meta:
                model = Skill
                fields = ("id", "fullname")

        class AnotherUserSerializer(serializers.ModelSerializer):
            fullname = serializers.CharField(source="username")
            my_skills = AnotherSkillSerializer(many=True, source="skills")

            class Meta:
                model = User
                fields = ("id", "fullname", "my_skills")
        self.Serializer = AnotherUserSerializer

def setUp(self):
        from .models import User

        contextual = self._getTarget()

        def has_xxx_context(xxx, replaced):
            def check(token, context):
                return replaced if xxx in context else []
            return check

        class ForContextualTestUserSerializer(serializers.ModelSerializer):
            class Meta:
                model = User
                fields = ('id', 'username')

            username = serializers.SerializerMethodField()

            @contextual(has_xxx_context('with_username', 'username'))
            def get_username(self, ob):
                return ob.username.split(" ", 1)[0]
        self.Serializer = ForContextualTestUserSerializer

def __init__(self, *args, **kwargs):
        serializers.ModelSerializer.__init__(self, *args, **kwargs)
        queryset = models.PersonEmail.objects.all()
        try:
            pk = self.context['view'].kwargs['pk']
        except KeyError:
            pk = None
        if pk is not None:
            try:
                queryset = queryset.exclude(person__id=pk)
            except ValueError:
                queryset = queryset.exclude(person__nb_id=pk)

        self.fields['address'] = serializers.EmailField(
            max_length=254,
            validators=[UniqueValidator(queryset=queryset)])

def test_modelserializer_charfield(self):
        class ArtistSerializer(serializers.ModelSerializer):
            id = HashidSerializerCharField(source_field='tests.Artist.id')

            class Meta:
                model = Artist
                fields = ('id', 'name')

        artist = Artist.objects.create(id=128, name="Test Artist")
        orig_id = artist.id
        s = ArtistSerializer(artist)
        self.assertEqual(Artist._meta.get_field('id').salt, s.fields['id'].hashid_salt)
        self.assertTrue(isinstance(s.data['id'], six.string_types))
        self.assertEqual(artist.id.hashid, s.data['id'])
        s2 = ArtistSerializer(artist, data={'id': 128, 'name': "Test Artist Changed"})
        self.assertTrue(s2.is_valid())
        artist = s2.save()
        self.assertEqual(artist.id, orig_id)
        self.assertEqual(artist.name, "Test Artist Changed")

def test_modelserializer_integerfield(self):
        class ArtistSerializer(serializers.ModelSerializer):
            id = HashidSerializerIntegerField(source_field=Artist._meta.get_field('id'))

            class Meta:
                model = Artist
                fields = ('id', 'name')

        artist = Artist.objects.create(id=256, name="Test Artist")
        orig_id = artist.id
        s = ArtistSerializer(artist)
        self.assertTrue(isinstance(s.data['id'], int))
        self.assertEqual(artist.id.id, s.data['id'])
        s2 = ArtistSerializer(artist, data={'id': 256, 'name': "Test Artist Changed"})
        self.assertTrue(s2.is_valid())
        artist = s2.save()
        self.assertEqual(artist.id, orig_id)
        self.assertEqual(artist.name, "Test Artist Changed")

def create(self, validated_data):
        account = Account(email=validated_data['email'],
                          first_name=validated_data['first_name'],
                          last_name=validated_data['last_name'])

        account.set_password(validated_data['password'])

        # matrix = MatrixApi()
        # account.matrix_token = matrix.register(validated_data['username'], validated_data['password'])['access_token']
        # account.matrix_id =
        account.save()
        return account

# class GroupSerializers(serializers.ModelSerializer):
#   class Meta:
#       model = Group
#       fields = ('group_type', 'members', 'classroom', 'creator')

def build_serializer(self, cls, model_name):
        """
        Dynamically build a model serializer class
        """
        class_name = "%sSerializer" % model_name
        meta_class = type('Meta', (), {'model': cls, 'fields': '__all__'})
        serializer_args = {'Meta': meta_class}

        if hasattr(cls, 'content_type'):
            serializer_args.update({
                'content_type': serializers.StringRelatedField()
            })

        model_serializer = type(class_name, (serializers.ModelSerializer,), serializer_args)

        return model_serializer

def create(self, validated_data):
        return serializers.ModelSerializer.create(self, validated_data)

def update(self, instance, validated_data):
        return serializers.ModelSerializer.update(self, instance, validated_data)

def create(self, validated_data):
        return serializers.ModelSerializer.create(self, validated_data)

def update(self, instance, validated_data):
        return serializers.ModelSerializer.update(self, instance, validated_data)

def create(self, validated_data):
        return serializers.ModelSerializer.create(self, validated_data)

def to_representation(self, instance):
        '''
        This method is overridden to remove blank fields from serialized output. We could put this into a subclassed
        ModelSerializer if we want it to apply to all our Serializers.
        :param instance:
        :return:
        '''
        rep = super().to_representation(instance)
        return {key: val for key, val in rep.items() if val}

def get_validators(self):
        """
        Hack to remove DRF's UniqueTogetherValidator when it concerns the UUID.

        See https://github.com/deis/deis/pull/2898#discussion_r23105147
        """
        validators = super(ModelSerializer, self).get_validators()
        for v in validators:
            if isinstance(v, UniqueTogetherValidator) and 'uuid' in v.fields:
                validators.remove(v)
        return validators

def get_validators(self):
        """
        Hack to remove DRF's UniqueTogetherValidator when it concerns the UUID.

        See https://github.com/deis/deis/pull/2898#discussion_r23105147
        """
        validators = super(ModelSerializer, self).get_validators()
        for v in validators:
            if isinstance(v, UniqueTogetherValidator) and 'uuid' in v.fields:
                validators.remove(v)
        return validators

def validate(self, attrs):
        email_or_username = attrs.get('email_or_username')
        password = attrs.get('password')

        if email_or_username and password:
            # Check if user sent email
            if validateEmail(email_or_username):
                user_request = get_object_or_404(
                    User,
                    email=email_or_username,
                )

                email_or_username = user_request.username

            user = authenticate(username=email_or_username, password=password)

            if user:
                if not user.is_active:
                    msg = _('User account is disabled.')
                    raise ValidationError(msg)
            else:
                msg = _('Unable to log in with provided credentials.')
                raise ValidationError(msg)
        else:
            msg = _('Must include "email or username" and "password"')
            raise ValidationError(msg)

        attrs['user'] = user
        return attrs


# class ProfileSerializer(serializers.ModelSerializer):
#
#     class Meta:
#         model = UserProfile
#         exclude = ('user', 'id', 'organization')
#

def get_profile_picture(self, obj):
        try:
            if obj.user_profile.profile_picture:
                return obj.user_profile.profile_picture.url
        except:
            return None
        return None


# class ProfileUserSerializer(serializers.ModelSerializer):
#
#     class Meta:
#         model = User
#         exclude = ('last_login', 'is_superuser', 'is_staff', 'is_active', 'date_joined', 'groups', 'user_permissions','password')
#         read_only_fields = ('username', 'email', 'last_login', 'date_joined', 'id')

def convert_serializer_field(field, is_input=True):
    """
    Converts a django rest frameworks field to a graphql field
    and marks the field as required if we are creating an input type
    and the field itself is required
    """

    graphql_type = get_graphene_type_from_serializer_field(field)

    args = []
    kwargs = {
        'description': field.help_text,
        'required': is_input and field.required,
    }

    # if it is a tuple or a list it means that we are returning
    # the graphql type and the child type
    if isinstance(graphql_type, (list, tuple)):
        kwargs['of_type'] = graphql_type[1]
        graphql_type = graphql_type[0]

    if isinstance(field, serializers.ModelSerializer):
        if is_input:
            graphql_type = convert_serializer_to_input_type(field.__class__)
        else:
            global_registry = get_global_registry()
            field_model = field.Meta.model
            args = [global_registry.get_type_for_model(field_model)]

    return graphql_type(*args, **kwargs)

def test_should_model_convert_field():

    class MyModelSerializer(serializers.ModelSerializer):
        class Meta:
            model = None
            fields = '__all__'

    assert_conversion(MyModelSerializer, graphene.Field, is_input=False)

def setUp(self):
        Group.objects.bulk_create([Group(name=name) for name in ['group1', 'group2', 'group3']])

        class GroupSerializer(ModelSerializer):
            class Meta:
                model = Group
                fields = '__all__'

        class GroupViewSet(ModelViewSet):
            queryset = Group.objects.all()
            serializer_class = GroupSerializer
            permission_classes = [DjangoObjectPermissions]
            filter_backends = [ChemoPermissionsFilter]

        self.user = User.objects.create_user(username='testuser', password='test123.')
        self.perm = Permission.objects.create(content_type=get_content_type(Group),
                                              name='Can view group', codename='view_group')
        self.access_rule = AccessRule.objects.create(ctype_source=get_content_type(User),
                                                     ctype_target=get_content_type(Group),
                                                     is_active=True,
                                                     relation_types=[{'GROUPS': None}])
        self.view = GroupViewSet

        self.patched_settings = modify_settings(
            AUTHENTICATION_BACKENDS={'append': self.backend}
        )
        self.patched_settings.enable()

def find_for_model(model, app_label=None, serializers_module='serializers'):
        """
        This is extends the serializer_registry.find_for_model by searching
        installed the app provided by either the app_label arg or the
        model._meta.app_label property, and the serializers_module arg
        it will loop through any classes found in this module and check for a
        Meta.model property matching the provided model and return if found.

        i.e. it will return the first modelserializer it finds matching provided
        model in the app.module provided, if non found raises ValueError
        """
        from clubhouse.core.options import serializer_registry, NotRegistered
        try:
            return serializer_registry.find_for_model(model)
        except NotRegistered:
            pass

        # In the event the serializer is not registered, return the first
        # serializer found in the app provided by app_label.serializer_module
        model = ensure_model(model)
        app_label = app_label if app_label else model._meta.app_label
        module_name = '%s.%s' % (app_label,serializers_module)

        try:
            members = sys.modules[module_name]
        except KeyError:
            from importlib import import_module
            import_module(module_name)
            members = sys.modules[module_name]

        for name, obj in inspect.getmembers(members,inspect.isclass):
            try:
                if issubclass(obj, serializers.ModelSerializer)\
                        and obj.Meta.model is model:
                    return obj
            except AttributeError:
                # Probably abstract
                continue

        raise ValueError('Could not find serializer for model: %s' % model)

def init_serializer(cls):
        if not hasattr(cls, 'serializer_class') or cls.serializer_class is None:
            if getattr(cls, 'primary_model', None) is None:
                cls.serializer_class = Serializer
            else:
                field_names = []
                for field in cls.primary_model._meta.get_fields():
                    if field.many_to_one or isinstance(field, (
                            django.db.models.fields.related.OneToOneField,
                            django.db.models.fields.related.ManyToManyField)):
                        field_name = getattr(field, 'name')
                    elif not field.is_relation:
                        field_name = getattr(field, 'attname')
                    else:
                        continue
                    if field_name not in (SETTINGS.MODEL_CREATOR, SETTINGS.MODEL_MODIFIER):
                        field_names.append(field_name)

                class BenchmarkSerializer(ModelSerializer):
                    class Meta:
                        model = cls.primary_model
                        fields = field_names
                cls.serializer_class = BenchmarkSerializer
            cls.serializer_is_custom = False
        else:
            cls.serializer_is_custom = True

def modelserializer_factory(model, serializer=None, fields=None, exclude=None):
    """
    Returns a ModelSerializer containing fields for the given model.

    :param model: model class.
    :param fields: is an optional list of field names. If provided, only the named
    fields will be included in the returned fields. If omitted or '__all__', all
    fields will be used.
    :param exclude: is an optional list of field names. If provided, the named fields
    will be excluded from the returned fields, even if they are listed in the ``fields``
    argument.
    :return: ModelSerializer class
    """

    # default values
    serializer = serializer or serializers.ModelSerializer

    attrs = {'model': model}
    if fields == '__all__':
        opts = model._meta.concrete_model._meta
        attrs['fields'] = [field.name for field in opts.fields if field.serialize]
    elif fields is not None:
        attrs['fields'] = fields
    if exclude is not None:
        attrs['exclude'] = exclude

    # create meta class
    parent = (object,)
    Meta = type('Meta', parent, attrs)

    # Give this new serializer class a reasonable name.
    class_name = model.__name__ + 'Serializer'

    # Class attributes for the new serializer class.
    serializer_class_attrs = {
        'Meta': Meta,
    }
    return type(serializer)(class_name, (serializer,), serializer_class_attrs)

def update(self, instance, validated_data):
        """Update.

        :param instance:
        :param validated_data:
        :return:
        """
        # Collect information on nested serializers
        __nested_serializers, __nested_serializers_data = \
            extract_nested_serializers(
                self,
                validated_data,
            )

        # Update the instance
        instance = super(ModelSerializer, self).update(
            instance,
            validated_data
        )

        # Assign fields to the `instance` one by one
        set_instance_values(
            __nested_serializers,
            __nested_serializers_data,
            instance
        )

        # Save the instance and return
        instance.save()
        return instance

def test_fields_value_is___all__(self):
        from .models import User

        class SlugUserSerializer(serializers.ModelSerializer):
            class Meta:
                model = User
                fields = '__all__'

        actual = self._callFUT(SlugUserSerializer)
        expected = ['id', 'password', 'last_login', 'is_superuser', 'username', 'first_name', 'last_name', 'email', 'is_staff', 'is_active', 'date_joined', 'groups__id', 'user_permissions__id']
        self.assertEqual(actual, expected)

def setUp(self):
        from django.contrib.auth.models import Permission, Group
        from .models import User, Skill
        # in django.contrib.auth.models
        #     permission *-* group, permission *-* user, permission *-* groups
        # in my tests.models:
        #     skill *- user

        class ContribPermissionSerializer(serializers.ModelSerializer):
            class Meta:
                model = Permission
                fields = "__all__"

        class SkillSerializer(serializers.ModelSerializer):
            class Meta:
                model = Skill
                fields = "__all__"

        class UserSerializer(serializers.ModelSerializer):
            skills = SkillSerializer(many=True)
            permissions = ContribPermissionSerializer(many=True)

            class Meta:
                model = User
                fields = "__all__"

        class ContribGroupSerializer(serializers.ModelSerializer):
            permissions = ContribPermissionSerializer(many=True)
            users = UserSerializer(many=True)

            class Meta:
                model = Group
                fields = "__all__"

        self.PermissionSerializer = ContribPermissionSerializer
        self.SkillSerializer = SkillSerializer
        self.UserSerializer = UserSerializer
        self.GroupSerializer = ContribGroupSerializer

def to_representation(self, obj):
        if isinstance(obj,UserProfile):
            return super(UserProfileSerializer,self).to_representation(obj)
        serializer = TokenSerializer(obj)
        return serializer.data

# class ScoreSerializer(serializers.ModelSerializer):
#     UserId = serializers.IntegerField(source='GiverPersonId_id',read_only=True) #Read olurken hangi user in verdigini anlamak icin kullanilir
#     Score = serializers.IntegerField(source='Point')
#     Name = serializers.CharField(source='GiverPersonId.user.first_name',read_only=True)
#     Image = serializers.ImageField(source='GiverPersonId.Photo', max_length=None, use_url=True, read_only=True)
#     class Meta(object):
#         model = Score
#         fields = ('Score','UserId','Name','Image')
#     def create(self, validated_data):
#         taker = self.context['view'].kwargs['pk']
#         score = Score.objects.create(TakerPersonId_id=taker ,GiverPersonId_id=self.context['request'].user.id, **validated_data)
#         scores = Score.objects.filter(TakerPersonId_id=taker)
#         total = 0.0
#         for score in scores:
#             total += score.Point
#         avarage_score =  total / len(scores)
#         user = UserProfile.objects.get(pk=taker)
#         user.Score = avarage_score
#         user.save()
#         return {'IsSuccess':True,'context':''}
#     def to_representation(self, obj):
#         if isinstance(obj,Score):
#             return super(ScoreSerializer,self).to_representation(obj)
#         serializer = ResultSerializer(obj)
#         return serializer.data

def test_default_modelserializer_field(self):
        class ArtistSerializer(serializers.ModelSerializer):
            class Meta:
                model = Artist
                fields = ('id', 'name')

        with self.assertRaises(exceptions.ImproperlyConfigured):
            ArtistSerializer().fields()  # Fields aren't built until first accessed

def get_serializer_class(self):
        if self.serializer_class is None:
            class AutoConfigModelSerializer(ModelSerializer):
                """Serializer class for configuration models."""
                class Meta(object):
                    """Meta information for AutoConfigModelSerializer."""
                    model = self.model

            self.serializer_class = AutoConfigModelSerializer

        return self.serializer_class

def get_raw_type_from_serializer_field(field):
    if isinstance(field, ListSerializer):
        return 'list'

    if isinstance(field, ModelSerializer):
        return 'model'
        # return smart_text(field.Meta.model.__name__).lower()

    name = field.__class__.__name__

    if name.endswith('Field'):
        name = smart_text(name[:-5])

    return smart_text(name).lower()

def _build_serializer(self, serializer_class, fields=None, instance=None):
        if serializer_class is None:
            return None
        kwargs = {}
        if hasattr(self, 'initial_data'):
            # Route initial data to the corresponding child serializer, e.g.
            # model data --> ModelSerializer.
            initial_data = self.initial_data or {}
            data = {k: v for k, v in initial_data.iteritems()
                    if k in fields}
            kwargs['data'] = data
        return serializer_class(
            context=self._context, partial=self.partial, instance=instance,
            **kwargs)

def generate_model_serializer(name, model, model_fields, bases=None):
    """
    Generates a `ModelSerializer` given the model_fields.

    The specified `model_fields` is a tuple of model fields properties and
    the already created drf_fields. The former are passed to the `Meta` class
    of serializer in order to be created afterwards, whereas the latter are
    specified directly to the serializer class.
    """
    field_properties, drf_fields = classify_model_fields(
        model_fields)
    if not (field_properties or drf_fields):
        return None
    drf_fields = drf_fields or {}
    meta_cls_content = {
        'model': model,
        'fields': drf_fields.keys() + field_properties.keys(),
        'extra_kwargs': field_properties,
    }
    cls_content = {
        field_name: serializer
        for field_name, serializer in drf_fields.iteritems()
    }
    custom_bases = map(utils.LOAD_CLASS, bases or [])
    base_cls = tuple(custom_bases) + (ApimasModelSerializer,)
    meta_cls = type('Meta', (object,), meta_cls_content)
    cls_content['Meta'] = meta_cls
    return type(name, base_cls, cls_content)

def _extract_field_info(self, model, field_name, field, fields, relationships, adapter, target_app, allow_recursion=False):
        if field_name == 'id':
            return None
        field_item = {
            'name': field_name,
            'type': adapter.field_type_mapping[field.__class__.__name__]
        }
        if isinstance(field, PrimaryKeyRelatedField) or isinstance(field, ManyRelatedField) \
                or isinstance(field, ModelSerializer):
            if model is None:
                field_item['related_model'] = field.queryset.model._meta.model_name.lower()
                field_item['app'] = target_app if target_app is not None else \
                    field.queryset.model._meta.app_label.lower()
                relationships.append(field_item)
            else:
                model_field = model._meta.get_field(field_name)
                field_item['related_model'] = model_field.related_model._meta.model_name.lower()
                field_item['app'] = target_app if target_app is not None else \
                    model_field.related_model._meta.app_label.lower()
                relationships.append(field_item)
                if hasattr(model_field, 'field'):
                    field_item['inverse'] = model_field.field.name
                elif hasattr(model_field, 'remote_field') and \
                        getattr(model_field.remote_field, 'related_name', None) is not None:
                    field_item['inverse'] = model_field.remote_field.related_name
                if field_item.get('inverse', '-')[-1] == '+':
                    field_item.pop('inverse')
            if isinstance(field, ModelSerializer):
                if hasattr(field, 'many') and field.many:
                    field_item['type'] = adapter.field_type_mapping['ManyRelatedField']
                else:
                    field_item['type'] = adapter.field_type_mapping['PrimaryKeyRelatedField']
        elif isinstance(field, ModelSerializer):
            field_item['related_model'] = field.queryset.model._meta.model_name.lower()
            field_item['app'] = target_app if target_app is not None else \
                field.queryset.model._meta.app_label.lower()
            relationships.append(field_item)
            if field.many:
                field_item['type'] = adapter.field_type_mapping['ManyRelatedField']
            else:
                field_item['type'] = adapter.field_type_mapping['PrimaryKeyRelatedField']
        elif isinstance(field, ListSerializer):
            child_rels = []
            child_fields = []
            self._extract_field_info(model, field_name, field.child, child_fields, child_rels, adapter, target_app)
            if len(child_rels) > 0:
                for item in child_rels:
                    item['type'] = adapter.field_type_mapping['ManyRelatedField']
                    item.pop('inverse', None)
                    relationships.append(item)
            else:
                field_item['type'] = adapter.field_type_mapping('ListField')
                fields.append(field_item)

        else:
            fields.append(field_item)

        return field_item

def update(self, instance, validated_data):
        reverse_relations = OrderedDict()
        relations = OrderedDict()

        # Sort fields by create priority
        fields = self.get_sorted_by_create_priority(self.fields)
        # Remove related fields from validated data for future manipulations
        for field_name, field in fields.items():
            if field.read_only:
                continue

            if isinstance(field, serializers.ListSerializer):
                if isinstance(field.child, serializers.ModelSerializer):
                    if validated_data.pop(field.source, None) is None:
                        # Skip field if field is not required or null allowed
                        continue
                    reverse_relations[field_name] = field.child

            if isinstance(field, serializers.ModelSerializer):
                if validated_data.pop(field.source, None) is None:
                    # Skip field if field is not required or null allowed
                    continue
                relations[field_name] = field

        nested_related_kwarg = getattr(self.Meta, 'nested_related_kwarg', None)
        if reverse_relations:
            assert nested_related_kwarg, \
                "Set `nested_related_kwarg` in Meta options for use nested " \
                "create feature"

        if relations:
            raise NotImplementedError("NestedUpdateMixin not provide update "
                                      "for direct relations")

        # Update instance
        instance = super(NestedUpdateMixin, self).update(
            instance, validated_data)

        if reverse_relations:
            self.update_reverse_relations(instance, reverse_relations)
            self.delete_reverse_relations_if_need(instance, reverse_relations)
        return instance

def create(self, validated_data):
        reverse_relations = OrderedDict()
        relations = OrderedDict()

        # Sort fields by create priority
        fields = self.get_sorted_by_create_priority(self.fields)
        # Remove related fields from validated data for future manipulations
        for field_name, field in fields.items():
            if field.read_only or field_name in self._ignore_creation:
                continue

            if isinstance(field, serializers.ListSerializer):
                if isinstance(field.child, serializers.ModelSerializer):
                    if validated_data.pop(field.source, None) is None:
                        # Skip field if field is not required or null allowed
                        continue
                    reverse_relations[field_name] = field.child

            if isinstance(field, serializers.ModelSerializer):
                if validated_data.pop(field.source, None) is None:
                    # Skip field if field is not required or null allowed
                    continue
                relations[field_name] = field

        nested_related_kwarg = getattr(self.Meta, 'nested_related_kwarg', None)
        if reverse_relations:
            assert nested_related_kwarg, \
                "Set `nested_related_kwarg` in Meta options for use nested " \
                "create feature"

        # Create direct relations (foreign key)
        for field_name, field in relations.items():
            serializer = self._get_new_serializer(
                field, data=self.initial_data[field_name])
            serializer.is_valid(raise_exception=True)
            validated_data[field.source] = serializer.save()

        # Create instance
        instance = super(NestedCreateMixin, self).create(validated_data)
        if reverse_relations:
            self.create_reverse_relations(instance, reverse_relations)

        return instance

def modelserializer_factory(model, serializer=serializers.ModelSerializer, fields=None, exclude=None, **kwargs):
    """
    Generate serializer basing on django's modelform_factory
    :param model: model we create serializer for
    :param serializer: base serializer class
    :param fields: list of fields to include in serializer
    :param exclude: list of fields to exclude from serializer
    :param kwargs: fields mapping
    :return:
    """

    # TODO: decide if we need cache and what to do with parameters tha can be different
    serializer_class = serializer_cache.get(model, None)

    if serializer_class:
        return serializer_class

    def _get_declared_fields(attrs):
        fields = [(field_name, attrs.pop(field_name))
                  for field_name, obj in list(attrs.items())
                  if isinstance(obj, serializers.Field)]
        fields.sort(key=lambda x: x[1]._creation_counter)
        return OrderedDict(fields)

    meta_attrs = {'model': model}
    if fields is not None:
        meta_attrs['fields'] = fields
    if exclude is not None:
        meta_attrs['exclude'] = exclude
    if fields is None and exclude is None:
        meta_attrs['fields'] = '__all__'

    parent = (object, )
    Meta = type(str('Meta'), parent, meta_attrs)
    class_name = model.__name__ + str('Serializer')

    serializer_class_attrs = {
        'Meta': Meta,
        '_get_declared_fields': _get_declared_fields(kwargs),
    }
    serializer_class = type(serializer)(class_name, (serializer,), serializer_class_attrs)
    serializer_cache[model] = serializer_class
    return serializer_class

def _validate_configuration(self):
        meta_cls = getattr(self, 'Meta', None)
        if meta_cls is None:
            raise ex.ApimasException('`Meta` class cannot be found')
        model_fields = getattr(meta_cls, 'model_fields', [])
        fields = getattr(meta_cls, 'extra_fields', [])
        if not (fields or model_fields):
            raise ex.ApimasException(
                '`extra_fields` and `model_fields` attributes are not'
                ' specified')
        if not (self.model_ser_cls or self.ser_cls):
            raise ex.ApimasException(
                'A `ContainerSerializer` must define a `ModelSerializer` class'
                ' or a `Serializer class')
        if not (self.model_ser_cls or self.ser_cls):
            raise ex.ApimasException(
                'A `ContainerSerializer` must include a ModelSerializer'
                ' and Serializer class')
        if self.model_ser_cls:
            mro = inspect.getmro(self.model_ser_cls)
            if serializers.HyperlinkedModelSerializer not in mro:
                raise ex.ApimasException(
                    'A model serializer class must inherit'
                    ' `serializers.ModelSerializer`')
        if self.ser_cls:
            mro = inspect.getmro(self.ser_cls)
            if serializers.BaseSerializer not in mro:
                raise ex.ApimasException(
                    'A serializer class must implement'
                    ' `serializers.BaseSerializer`')
        return model_fields, fields