python类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)