Объявление сериализаторов¶

Давайте начнем с создания простого объекта, который мы можем использовать для примера:

from datetime import datetime

class Comment:
    def __init__(self, email, content, created=None):
        self.email = email
        self.content = content
        self.created = created or datetime.now()

comment = Comment(email='leila@example.com', content='foo bar')

Мы объявим сериализатор, который мы можем использовать для сериализации и десериализации данных, соответствующих объектам Comment.

Объявление сериализатора очень похоже на объявление формы:

from rest_framework import serializers

class CommentSerializer(serializers.Serializer):
    email = serializers.EmailField()
    content = serializers.CharField(max_length=200)
    created = serializers.DateTimeField()

Сериализация объектов¶

Теперь мы можем использовать CommentSerializer для сериализации комментария или списка комментариев. Опять же, использование класса Serializer очень похоже на использование класса Form.

serializer = CommentSerializer(comment)
serializer.data
# {'email': 'leila@example.com', 'content': 'foo bar', 'created': '2016-01-27T15:17:10.375877'}

На этом этапе мы перевели экземпляр модели в собственные типы данных Python. Для завершения процесса сериализации мы выводим данные в json.

from rest_framework.renderers import JSONRenderer

json = JSONRenderer().render(serializer.data)
json
# b'{"email":"leila@example.com","content":"foo bar","created":"2016-01-27T15:17:10.375877"}'

Десериализация объектов¶

Десериализация аналогична. Сначала мы разбираем поток на собственные типы данных Python…

import io
from rest_framework.parsers import JSONParser

stream = io.BytesIO(json)
data = JSONParser().parse(stream)

затем мы восстанавливаем эти родные типы данных в словарь проверенных данных.

serializer = CommentSerializer(data=data) serializer.is_valid() # True serializer.validated_data # {„content“: „foo bar“, „email“: „leila@example.com“, „created“: datetime.datetime(2012, 08, 22, 16, 20, 09, 822243)}

Сохранение экземпляров¶

Если мы хотим иметь возможность возвращать полные экземпляры объектов на основе проверенных данных, нам необходимо реализовать один или оба метода .create() и .update(). Например:

class CommentSerializer(serializers.Serializer):
    email = serializers.EmailField()
    content = serializers.CharField(max_length=200)
    created = serializers.DateTimeField()

    def create(self, validated_data):
        return Comment(**validated_data)

    def update(self, instance, validated_data):
        instance.email = validated_data.get('email', instance.email)
        instance.content = validated_data.get('content', instance.content)
        instance.created = validated_data.get('created', instance.created)
        return instance

Если ваши экземпляры объектов соответствуют моделям Django, вы также захотите убедиться, что эти методы сохраняют объект в базе данных. Например, если Comment является моделью Django, методы могут выглядеть следующим образом:

def create(self, validated_data):
    return Comment.objects.create(**validated_data)

def update(self, instance, validated_data):
    instance.email = validated_data.get('email', instance.email)
    instance.content = validated_data.get('content', instance.content)
    instance.created = validated_data.get('created', instance.created)
    instance.save()
    return instance

Теперь при десериализации данных мы можем вызвать .save(), чтобы вернуть экземпляр объекта, основанный на проверенных данных.

comment = serializer.save()

Вызов .save() приведет либо к созданию нового экземпляра, либо к обновлению существующего, в зависимости от того, был ли передан существующий экземпляр при инстанцировании класса сериализатора:

# .save() will create a new instance.
serializer = CommentSerializer(data=data)

# .save() will update the existing `comment` instance.
serializer = CommentSerializer(comment, data=data)

Методы .create() и .update() являются необязательными. Вы можете реализовать либо ни один из них, либо один, либо оба, в зависимости от того, как будет использоваться ваш класс сериализатора.

serializer.save(owner=request.user)

class ContactForm(serializers.Serializer):
    email = serializers.EmailField()
    message = serializers.CharField()

    def save(self):
        email = self.validated_data['email']
        message = self.validated_data['message']
        send_email(from=email, message=message)

Валидация¶

При десериализации данных всегда нужно вызывать is_valid() перед попыткой получить доступ к проверенным данным или сохранить экземпляр объекта. Если возникнут ошибки валидации, свойство .errors будет содержать словарь, представляющий сообщения об ошибках. Например:

serializer = CommentSerializer(data={'email': 'foobar', 'content': 'baz'})
serializer.is_valid()
# False
serializer.errors
# {'email': ['Enter a valid e-mail address.'], 'created': ['This field is required.']}

Каждый ключ в словаре будет именем поля, а значения будут списками строк любых сообщений об ошибках, соответствующих этому полю. Также может присутствовать ключ non_field_errors, который будет перечислять любые общие ошибки валидации. Имя ключа non_field_errors может быть настроено с помощью параметра NON_FIELD_ERRORS_KEY REST framework.

При десериализации списка элементов ошибки будут возвращены в виде списка словарей, представляющих каждый из десериализованных элементов.

# Return a 400 response if the data was invalid.
serializer.is_valid(raise_exception=True)

from rest_framework import serializers

class BlogPostSerializer(serializers.Serializer):
    title = serializers.CharField(max_length=100)
    content = serializers.CharField()

    def validate_title(self, value):
        """
        Check that the blog post is about Django.
        """
        if 'django' not in value.lower():
            raise serializers.ValidationError("Blog post is not about Django")
        return value

from rest_framework import serializers

class EventSerializer(serializers.Serializer):
    description = serializers.CharField(max_length=100)
    start = serializers.DateTimeField()
    finish = serializers.DateTimeField()

    def validate(self, data):
        """
        Check that start is before finish.
        """
        if data['start'] > data['finish']:
            raise serializers.ValidationError("finish must occur after start")
        return data

def multiple_of_ten(value):
    if value % 10 != 0:
        raise serializers.ValidationError('Not a multiple of ten')

class GameRecord(serializers.Serializer):
    score = IntegerField(validators=[multiple_of_ten])
    ...

class EventSerializer(serializers.Serializer):
    name = serializers.CharField()
    room_number = serializers.IntegerField(choices=[101, 102, 103, 201])
    date = serializers.DateField()

    class Meta:
        # Each room only has one event per day.
        validators = [
            UniqueTogetherValidator(
                queryset=Event.objects.all(),
                fields=['room_number', 'date']
            )
        ]

Доступ к исходным данным и экземпляру¶

При передаче начального объекта или набора запросов экземпляру сериализатора, объект будет доступен как .instance. Если начальный объект не передан, то атрибут .instance будет None.

При передаче данных экземпляру сериализатора немодифицированные данные будут доступны как .initial_data. Если аргумент ключевого слова data не передан, то атрибут .initial_data не будет существовать.

Частичные обновления¶

По умолчанию сериализаторам должны передаваться значения для всех обязательных полей, иначе они будут выдавать ошибки валидации. Вы можете использовать аргумент partial для того, чтобы разрешить частичное обновление.

# Update `comment` with partial data
serializer = CommentSerializer(comment, data={'content': 'foo bar'}, partial=True)

Работа с вложенными объектами¶

Предыдущие примеры хорошо подходят для работы с объектами, которые имеют только простые типы данных, но иногда нам также необходимо иметь возможность представлять более сложные объекты, где некоторые атрибуты объекта могут быть не простыми типами данных, такими как строки, даты или целые числа.

Класс Serializer сам является типом Field , и может быть использован для представления отношений, где один тип объекта вложен в другой.

class UserSerializer(serializers.Serializer):
    email = serializers.EmailField()
    username = serializers.CharField(max_length=100)

class CommentSerializer(serializers.Serializer):
    user = UserSerializer()
    content = serializers.CharField(max_length=200)
    created = serializers.DateTimeField()

Если вложенное представление может опционально принимать значение None, вы должны передать флаг required=False в сериализатор вложенного представления.

class CommentSerializer(serializers.Serializer):
    user = UserSerializer(required=False)  # May be an anonymous user.
    content = serializers.CharField(max_length=200)
    created = serializers.DateTimeField()

Аналогично, если вложенное представление должно быть списком элементов, необходимо передать флаг many=True в сериализатор вложенного представления.

class CommentSerializer(serializers.Serializer):
    user = UserSerializer(required=False)
    edits = EditItemSerializer(many=True)  # A nested list of 'edit' items.
    content = serializers.CharField(max_length=200)
    created = serializers.DateTimeField()

Записываемые вложенные представления¶

При работе с вложенными представлениями, поддерживающими десериализацию данных, любые ошибки с вложенными объектами будут вложены под именем поля вложенного объекта.

serializer = CommentSerializer(data={'user': {'email': 'foobar', 'username': 'doe'}, 'content': 'baz'})
serializer.is_valid()
# False
serializer.errors
# {'user': {'email': ['Enter a valid e-mail address.']}, 'created': ['This field is required.']}

Аналогично, свойство .validated_data будет включать вложенные структуры данных.

class UserSerializer(serializers.ModelSerializer):
    profile = ProfileSerializer()

    class Meta:
        model = User
        fields = ['username', 'email', 'profile']

    def create(self, validated_data):
        profile_data = validated_data.pop('profile')
        user = User.objects.create(**validated_data)
        Profile.objects.create(user=user, **profile_data)
        return user

def update(self, instance, validated_data):
    profile_data = validated_data.pop('profile')
    # Unless the application properly enforces that this field is
    # always set, the following could raise a `DoesNotExist`, which
    # would need to be handled.
    profile = instance.profile

    instance.username = validated_data.get('username', instance.username)
    instance.email = validated_data.get('email', instance.email)
    instance.save()

    profile.is_premium_member = profile_data.get(
        'is_premium_member',
        profile.is_premium_member
    )
    profile.has_support_contract = profile_data.get(
        'has_support_contract',
        profile.has_support_contract
     )
    profile.save()

    return instance

class UserManager(models.Manager):
    ...

    def create(self, username, email, is_premium_member=False, has_support_contract=False):
        user = User(username=username, email=email)
        user.save()
        profile = Profile(
            user=user,
            is_premium_member=is_premium_member,
            has_support_contract=has_support_contract
        )
        profile.save()
        return user

def create(self, validated_data):
    return User.objects.create(
        username=validated_data['username'],
        email=validated_data['email'],
        is_premium_member=validated_data['profile']['is_premium_member'],
        has_support_contract=validated_data['profile']['has_support_contract']
    )

Работа с несколькими объектами¶

Класс Serializer также может обрабатывать сериализацию или десериализацию списков объектов.

queryset = Book.objects.all()
serializer = BookSerializer(queryset, many=True)
serializer.data
# [
#     {'id': 0, 'title': 'The electric kool-aid acid test', 'author': 'Tom Wolfe'},
#     {'id': 1, 'title': 'If this is a man', 'author': 'Primo Levi'},
#     {'id': 2, 'title': 'The wind-up bird chronicle', 'author': 'Haruki Murakami'}
# ]

Включение дополнительного контекста¶

В некоторых случаях необходимо предоставить сериализатору дополнительный контекст в дополнение к сериализуемому объекту. Одним из распространенных случаев является использование сериализатора, который включает отношения с гиперссылками, что требует, чтобы сериализатор имел доступ к текущему запросу, чтобы он мог правильно генерировать полностью определенные URL.

Вы можете предоставить произвольный дополнительный контекст, передав аргумент context при инстанцировании сериализатора. Например:

serializer = AccountSerializer(account, context={'request': request})
serializer.data
# {'id': 6, 'owner': 'denvercoder9', 'created': datetime.datetime(2013, 2, 12, 09, 44, 56, 678870), 'details': 'http://example.com/accounts/6/details'}

Контекстный словарь может быть использован в любой логике поля сериализатора, например, в пользовательском методе .to_representation(), путем обращения к атрибуту self.context.

Указание того, какие поля следует включить¶

Если вы хотите, чтобы в сериализаторе модели использовалось только подмножество полей по умолчанию, вы можете сделать это с помощью опций fields или exclude, так же как и с помощью ModelForm. Настоятельно рекомендуется явно задать все поля, которые должны быть сериализованы, с помощью атрибута fields. Это уменьшит вероятность непреднамеренного раскрытия данных при изменении ваших моделей.

Например:

class AccountSerializer(serializers.ModelSerializer):
    class Meta:
        model = Account
        fields = ['id', 'account_name', 'users', 'created']

Вы также можете установить атрибут fields в специальное значение '__all__', чтобы указать, что все поля в модели должны быть использованы.

Например:

class AccountSerializer(serializers.ModelSerializer):
    class Meta:
        model = Account
        fields = '__all__'

Вы можете установить атрибут exclude в список полей, которые должны быть исключены из сериализатора.

Например:

class AccountSerializer(serializers.ModelSerializer):
    class Meta:
        model = Account
        exclude = ['users']

В приведенном выше примере, если модель Account имела 3 поля account_name , users , и created , это приведет к тому, что поля account_name и created будут сериализованы.

Имена в атрибутах fields и exclude обычно отображаются на поля модели в классе модели.

Альтернативные имена в опциях fields могут указывать на свойства или методы, не принимающие аргументов, которые существуют в классе модели.

Начиная с версии 3.3.0, обязательным является предоставление одного из атрибутов fields или exclude.

Указание вложенной сериализации¶

По умолчанию ModelSerializer использует первичные ключи для отношений, но вы также можете легко генерировать вложенные представления, используя опцию depth:

class AccountSerializer(serializers.ModelSerializer):
    class Meta:
        model = Account
        fields = ['id', 'account_name', 'users', 'created']
        depth = 1

Опция depth должна быть установлена на целочисленное значение, которое указывает глубину отношений, которые должны быть пройдены перед возвратом к плоскому представлению.

Если вы хотите настроить способ сериализации, вам нужно будет определить поле самостоятельно.

Указание полей в явном виде¶

Вы можете добавить дополнительные поля к классу ModelSerializer или переопределить поля по умолчанию, объявив поля в классе, как и для класса Serializer.

class AccountSerializer(serializers.ModelSerializer):
    url = serializers.CharField(source='get_absolute_url', read_only=True)
    groups = serializers.PrimaryKeyRelatedField(many=True)

    class Meta:
        model = Account

Дополнительные поля могут соответствовать любому свойству или вызываемому объекту модели.

Указание полей, доступных только для чтения¶

Возможно, вы захотите указать несколько полей как доступные только для чтения. Вместо явного добавления каждого поля с помощью атрибута read_only=True, вы можете использовать сокращенную опцию Meta, read_only_fields.

Этот параметр должен представлять собой список или кортеж имен полей и объявляется следующим образом:

class AccountSerializer(serializers.ModelSerializer):
    class Meta:
        model = Account
        fields = ['id', 'account_name', 'users', 'created']
        read_only_fields = ['account_name']

Поля модели, для которых установлено editable=False, и поля AutoField по умолчанию будут установлены в режим «только для чтения», и их не нужно добавлять к опции read_only_fields.

Примечание: Существует особый случай, когда поле, доступное только для чтения, является частью ограничения unique_together на уровне модели. В этом случае поле требуется классу сериализатора для проверки ограничения, но также не должно редактироваться пользователем.

Правильным способом решения этой проблемы является явное указание поля в сериализаторе, предоставляя аргументы ключевого слова read_only=True и default=….

Одним из примеров этого является отношение только для чтения к текущему аутентифицированному User, который является unique_together с другим идентификатором. В этом случае вы бы объявили поле user следующим образом:

user = serializers.PrimaryKeyRelatedField(read_only=True, default=serializers.CurrentUserDefault())

Пожалуйста, ознакомьтесь с Validators Documentation для получения подробной информации о классах UniqueTogetherValidator и CurrentUserDefault.

Дополнительные аргументы ключевых слов¶

Также есть возможность указать произвольные дополнительные аргументы ключевых слов для полей, используя опцию extra_kwargs. Как и в случае с read_only_fields , это означает, что вам не нужно явно объявлять поле в сериализаторе.

Этот параметр представляет собой словарь, отображающий имена полей на словарь аргументов ключевых слов. Например:

class CreateUserSerializer(serializers.ModelSerializer):
    class Meta:
        model = User
        fields = ['email', 'username', 'password']
        extra_kwargs = {'password': {'write_only': True}}

    def create(self, validated_data):
        user = User(
            email=validated_data['email'],
            username=validated_data['username']
        )
        user.set_password(validated_data['password'])
        user.save()
        return user

Следует помнить, что если поле уже было явно объявлено в классе сериализатора, то опция extra_kwargs будет проигнорирована.

Реляционные поля¶

При сериализации экземпляров модели существует несколько различных способов представления отношений. Представление по умолчанию для ModelSerializer заключается в использовании первичных ключей связанных экземпляров.

Альтернативные представления включают сериализацию с помощью гиперссылок, сериализацию полных вложенных представлений или сериализацию с помощью пользовательского представления.

Для получения подробной информации см. документацию serializer relations.

Настройка сопоставлений полей¶

Класс ModelSerializer также предоставляет API, который вы можете переопределить, чтобы изменить способ автоматического определения полей сериализатора при инстанцировании сериализатора.

Обычно, если ModelSerializer не генерирует нужные вам поля по умолчанию, вы должны либо добавить их в класс явно, либо просто использовать вместо них обычный класс Serializer. Однако в некоторых случаях вы можете захотеть создать новый базовый класс, определяющий, как создаются поля сериализатора для любой конкретной модели.

Отображение полей модели Django на поля сериализатора фреймворка REST. Вы можете переопределить это отображение, чтобы изменить поля сериализатора по умолчанию, которые должны использоваться для каждого поля модели.

Это свойство должно быть классом поля сериализатора, который по умолчанию используется для реляционных полей.

Для ModelSerializer это значение по умолчанию равно PrimaryKeyRelatedField.

Для HyperlinkedModelSerializer это значение по умолчанию равно serializers.HyperlinkedRelatedField.

Класс поля сериализатора, который должен использоваться для любого поля url на сериализаторе.

По умолчанию serializers.HyperlinkedIdentityField

Класс поля сериализатора, который должен использоваться для любых полей выбора в сериализаторе.

По умолчанию serializers.ChoiceField

Следующие методы вызываются для определения класса и аргументов ключевых слов для каждого поля, которое должно быть автоматически включено в сериализатор. Каждый из этих методов должен возвращать кортеж из двух значений (field_class, field_kwargs).

Вызывается для генерации поля сериализатора, которое сопоставляется со стандартным полем модели.

Реализация по умолчанию возвращает класс сериализатора на основе атрибута serializer_field_mapping.

Вызывается для генерации поля сериализатора, которое сопоставляется с полем реляционной модели.

Реализация по умолчанию возвращает класс сериализатора на основе атрибута serializer_related_field.

Аргумент relation_info представляет собой именованный кортеж, содержащий model_field , related_model , to_many и has_through_model свойства.

Вызывается для генерации поля сериализатора, которое сопоставляется с полем реляционной модели, когда установлена опция depth.

Реализация по умолчанию динамически создает вложенный класс сериализатора на основе ModelSerializer или HyperlinkedModelSerializer.

Значение nested_depth будет равно значению опции depth, минус один.

Аргумент relation_info представляет собой именованный кортеж, содержащий model_field , related_model , to_many и has_through_model свойства.

Вызывается для генерации поля сериализатора, которое сопоставляется со свойством или методом с нулевым аргументом класса модели.

Реализация по умолчанию возвращает класс ReadOnlyField.

Вызывается для генерации поля сериализатора для собственного поля сериализатора url. Реализация по умолчанию возвращает класс HyperlinkedIdentityField.

Вызывается, если имя поля не сопоставлено ни с одним полем или свойством модели. Реализация по умолчанию вызывает ошибку, хотя подклассы могут настраивать это поведение.

Абсолютные и относительные URL-адреса¶

При инстанцировании HyperlinkedModelSerializer вы должны включить текущий request в контекст сериализатора, например:

serializer = AccountSerializer(queryset, context={'request': request})

Это гарантирует, что гиперссылки могут включать соответствующее имя хоста, так что результирующее представление использует полные URL-адреса, такие как:

http://api.example.com/accounts/1/

Вместо относительных URL-адресов, таких как:

/accounts/1/

Если вы хотите использовать относительные URL, вы должны явно передать {'request': None} в контексте сериализатора.

Как определяются представления с гиперссылками¶

Необходимо определить, какие представления следует использовать для гиперссылок на экземпляры модели.

По умолчанию предполагается, что гиперссылки соответствуют имени представления, которое соответствует стилю '{model_name}-detail' , и ищет экземпляр по аргументу ключевого слова pk.

Вы можете переопределить имя представления поля URL и поле поиска, используя одну или обе опции view_name и lookup_field в параметре extra_kwargs, как показано ниже:

class AccountSerializer(serializers.HyperlinkedModelSerializer):
    class Meta:
        model = Account
        fields = ['account_url', 'account_name', 'users', 'created']
        extra_kwargs = {
            'url': {'view_name': 'accounts', 'lookup_field': 'account_name'},
            'users': {'lookup_field': 'username'}
        }

В качестве альтернативы вы можете явно задать поля в сериализаторе. Например:

class AccountSerializer(serializers.HyperlinkedModelSerializer):
    url = serializers.HyperlinkedIdentityField(
        view_name='accounts',
        lookup_field='slug'
    )
    users = serializers.HyperlinkedRelatedField(
        view_name='user-detail',
        lookup_field='username',
        many=True,
        read_only=True
    )

    class Meta:
        model = Account
        fields = ['url', 'account_name', 'users', 'created']

Совет: Правильное сопоставление гиперссылочных представлений и вашего URL conf иногда может быть немного сложным. Печать repr экземпляра HyperlinkedModelSerializer - особенно полезный способ проверить, какие именно имена представлений и полей поиска должны сопоставлять отношения.

Изменение имени поля URL¶

По умолчанию имя поля URL имеет значение „url“. Вы можете отменить это глобально, используя параметр URL_FIELD_NAME.

Переопределение поведения сериализации и десериализации¶

Если вам нужно изменить поведение сериализации или десериализации класса сериализатора, вы можете сделать это, переопределив методы .to_representation() или .to_internal_value().

Некоторые причины, по которым это может быть полезно, включают…

• Добавление нового поведения для новых базовых классов сериализаторов.

• Небольшое изменение поведения существующего класса.

• Улучшение производительности сериализации для часто используемой конечной точки API, которая возвращает много данных.

Подписи для этих методов следующие:

def to_representation(self, instance):
    """Convert `username` to lowercase."""
    ret = super().to_representation(instance)
    ret['username'] = ret['username'].lower()
    return ret

Наследование сериализатора¶

Подобно формам Django, вы можете расширять и повторно использовать сериализаторы с помощью наследования. Это позволяет вам объявить общий набор полей или методов в родительском классе, который затем может быть использован в нескольких сериализаторах. Например,

class MyBaseSerializer(Serializer):
    my_field = serializers.CharField()

    def validate_my_field(self, value):
        ...

class MySerializer(MyBaseSerializer):
    ...

Как и классы Django Model и ModelForm, внутренний класс Meta в сериализаторах не наследуется неявно от внутренних классов своих родителей Meta. Если вы хотите, чтобы класс Meta наследовался от родительского класса, вы должны сделать это явно. Например:

class AccountSerializer(MyBaseSerializer):
    class Meta(MyBaseSerializer.Meta):
        model = Account

Обычно мы рекомендуем не использовать наследование для внутренних классов Meta, а вместо этого объявлять все опции явно.

Кроме того, следующие предостережения относятся к наследованию сериализаторов:

• Применяются обычные правила разрешения имен Python. Если у вас есть несколько базовых классов, которые объявляют Meta внутренний класс, будет использоваться только первый. Это означает дочерний Meta , если он существует, иначе Meta первого родителя и т.д.

• Можно декларативно удалить Field, унаследованный от родительского класса, установив имя None в подклассе.

     class MyBaseSerializer(ModelSerializer):
         my_field = serializers.CharField()
  
     class MySerializer(MyBaseSerializer):
         my_field = None
  
  
  However, you can only use this technique to opt out from a field defined declaratively by a parent class; it won’t prevent the ``ModelSerializer`` from generating a default field. To opt-out from default fields, see :doc:`Specifying which fields to include <#specifying-which-fields-to-include>`.
  

Динамическое изменение полей¶

После инициализации сериализатора к словарю полей, установленных на сериализаторе, можно получить доступ с помощью атрибута .fields. Доступ и изменение этого атрибута позволяет динамически модифицировать сериализатор.

Изменение аргумента fields напрямую позволяет вам делать такие интересные вещи, как изменение аргументов полей сериализатора во время выполнения, а не в момент объявления сериализатора.

Например, если вы хотите иметь возможность установить, какие поля должны использоваться сериализатором в момент его инициализации, вы можете создать класс сериализатора следующим образом:

class DynamicFieldsModelSerializer(serializers.ModelSerializer):
    """
    A ModelSerializer that takes an additional `fields` argument that
    controls which fields should be displayed.
    """

    def __init__(self, *args, **kwargs):
        # Don't pass the 'fields' arg up to the superclass
        fields = kwargs.pop('fields', None)

        # Instantiate the superclass normally
        super(DynamicFieldsModelSerializer, self).__init__(*args, **kwargs)

        if fields is not None:
            # Drop any fields that are not specified in the `fields` argument.
            allowed = set(fields)
            existing = set(self.fields)
            for field_name in existing - allowed:
                self.fields.pop(field_name)

Это позволит вам сделать следующее:

>>> class UserSerializer(DynamicFieldsModelSerializer):
>>>     class Meta:
>>>         model = User
>>>         fields = ['id', 'username', 'email']
>>>
>>> print(UserSerializer(user))
{'id': 2, 'username': 'jonwatts', 'email': 'jon@example.com'}
>>>
>>> print(UserSerializer(user, fields=('id', 'email')))
{'id': 2, 'email': 'jon@example.com'}

Настройка полей по умолчанию¶

REST framework 2 предоставил API, позволяющий разработчикам переопределять, как класс ModelSerializer будет автоматически генерировать набор полей по умолчанию.

Этот API включал .get_field() , .get_pk_field() и другие методы.

Поскольку сериализаторы были кардинально переработаны в версии 3.0, этот API больше не существует. Вы все еще можете изменять создаваемые поля, но вам придется обратиться к исходному коду, и имейте в виду, что если изменения, которые вы делаете, направлены против частных частей API, то они могут быть изменены.

Django REST marshmallow¶

Пакет django-rest-marshmallow предоставляет альтернативную реализацию сериализаторов, используя библиотеку python marshmallow. Он предоставляет тот же API, что и сериализаторы фреймворка REST, и может быть использован в качестве замены в некоторых случаях.

Серпи¶

Пакет serpy - это альтернативная реализация сериализаторов, созданная для скорости. Serpy сериализует сложные типы данных в простые нативные типы. Родные типы могут быть легко преобразованы в JSON или любой другой необходимый формат.

MongoengineModelSerializer¶

Пакет django-rest-framework-mongoengine предоставляет класс MongoEngineModelSerializer сериализатора, который поддерживает использование MongoDB в качестве уровня хранения данных для REST-фреймворка Django.

GeoFeatureModelSerializer¶

Пакет django-rest-framework-gis предоставляет класс сериализатора GeoFeatureModelSerializer, который поддерживает GeoJSON как для операций чтения, так и для операций записи.

HStoreSerializer¶

Пакет django-rest-framework-hstore предоставляет HStoreSerializer для поддержки django-hstore DictionaryField модельного поля и его schema-mode возможности.

Динамический REST¶

Пакет dynamic-rest расширяет интерфейсы ModelSerializer и ModelViewSet, добавляя параметры запроса API для фильтрации, сортировки, включения/исключения всех полей и отношений, определенных вашими сериализаторами.

Миксин динамических полей¶

Пакет drf-dynamic-fields предоставляет миксин для динамического ограничения полей сериализатора подмножеством, заданным параметром URL.

DRF FlexFields¶

Пакет drf-flex-fields расширяет ModelSerializer и ModelViewSet для обеспечения широко используемой функциональности для динамической установки полей и расширения примитивных полей во вложенные модели, как из параметров URL, так и из определений класса вашего сериализатора.

Расширения сериализатора¶

Пакет django-rest-framework-serializer-extensions предоставляет набор инструментов для DRY up ваших сериализаторов, позволяя определять поля на основе каждого представления/запроса. Поля могут быть внесены в белый или черный список, а дочерние сериализаторы могут быть дополнительно расширены.

Формы HTML JSON¶

Пакет html-json-forms предоставляет алгоритм и сериализатор для обработки представлений <form> в соответствии с (неактивным) HTML JSON Form specification. Сериализатор облегчает обработку произвольно вложенных структур JSON в HTML. Например, <input name="items[0][id]" value="5"> будет интерпретировано как {"items": [{"id": "5"}]}.

DRF-Base64¶

DRF-Base64 предоставляет набор сериализаторов полей и моделей, который обрабатывает загрузку файлов в base64-кодировке.

QueryFields¶

djangorestframework-queryfields позволяет клиентам API указать, какие поля будут отправлены в ответе с помощью параметров запроса включения/исключения.

DRF Записываемый вложенный¶

Пакет drf-writable-nested предоставляет записываемый сериализатор вложенных моделей, который позволяет создавать/обновлять модели с вложенными связанными данными.

DRF Шифровать содержимое¶

Пакет drf-encrypt-content помогает вам шифровать данные, сериализованные с помощью ModelSerializer. Он также содержит некоторые вспомогательные функции. Которые помогут вам зашифровать ваши данные.