def
                __init__(self, instance=None, data=empty, **kwargs):
        self.instance = instance
        if data isnot empty:
            self.initial_data = data
        self.partial = kwargs.pop(‘partial‘, False)
        self._context = kwargs.pop(‘context‘, {})
        kwargs.pop(‘many‘, None)
        super().__init__(**kwargs)

                def
                __new__(cls, *args, **kwargs):
        # We override this method in order to automagically create# `ListSerializer` classes instead when `many=True` is set.if kwargs.pop(‘many‘, False):
            return cls.many_init(*args, **kwargs)
        return super().__new__(cls, *args, **kwargs)

    @classmethod
    def many_init(cls, *args, **kwargs):
        """
        This method implements the creation of a `ListSerializer` parent
        class when `many=True` is used. You can customize it if you need to
        control which keyword arguments are passed to the parent, and
        which are passed to the child.

        Note that we‘re over-cautious in passing most arguments to both parent
        and child classes in order to try to cover the general case. If you‘re
        overriding this method you‘ll probably want something much simpler, eg:

        @classmethod
        def many_init(cls, *args, **kwargs):
            kwargs[‘child‘] = cls()
            return CustomListSerializer(*args, **kwargs)
        """
        allow_empty = kwargs.pop(‘allow_empty‘, None)
        child_serializer = cls(*args, **kwargs)
        list_kwargs = {
            ‘child‘: child_serializer,
        }
        if allow_empty isnot None:
            list_kwargs[‘allow_empty‘] = allow_empty
        list_kwargs.update({
            key: value for key, value in kwargs.items()
            if key in LIST_SERIALIZER_KWARGS
        })
        meta = getattr(cls, ‘Meta‘, None)
        list_serializer_class = getattr(meta, ‘list_serializer_class‘, ListSerializer)
        return list_serializer_class(*args, **list_kwargs)

                def
                 to_internal_value(self, data):
        
                raise NotImplementedError(‘`to_internal_value()` must be implemented.‘)

    def to_representation(self, instance):
        raise NotImplementedError(‘`to_representation()` must be implemented.‘)

    def update(self, instance, validated_data):
        raise NotImplementedError(‘`update()` must be implemented.‘)

    def create(self, validated_data):
        raise NotImplementedError(‘`create()` must be implemented.‘)

                def save(self, **kwargs):
        assertnot hasattr(self, ‘save_object‘), (
            ‘Serializer `%s.%s` has old-style version 2 `.save_object()` ‘‘that is no longer compatible with REST framework 3. ‘‘Use the new-style `.create()` and `.update()` methods instead.‘ %
            (self.__class__.__module__, self.__class__.__name__)
        )

        assert hasattr(self, ‘_errors‘), (
            ‘You must call `.is_valid()` before calling `.save()`.‘
        )

        assertnot self.errors, (
            ‘You cannot call `.save()` on a serializer with invalid data.‘
        )

        # Guard against incorrect use of `serializer.save(commit=False)`assert‘commit‘notin kwargs, (
            "‘commit‘ is not a valid keyword argument to the ‘save()‘ method. ""If you need to access data before committing to the database then ""inspect ‘serializer.validated_data‘ instead. ""You can also pass additional keyword arguments to ‘save()‘ if you ""need to set extra attributes on the saved model instance. ""For example: ‘serializer.save(owner=request.user)‘.‘"
        )

        assertnot hasattr(self, ‘_data‘), (
            "You cannot call `.save()` after accessing `serializer.data`.""If you need to access data before committing to the database then ""inspect ‘serializer.validated_data‘ instead. "
        )

        validated_data = dict(
            list(self.validated_data.items()) +
            list(kwargs.items())
        )
        if self.instance isnot None:
            self.instance = self.update(self.instance, validated_data)
            assert self.instance isnot None, (
                ‘`update()` did not return an object instance.‘
            )
        else:
            self.instance = self.create(validated_data)
            assert self.instance isnot None, (
                ‘`create()` did not return an object instance.‘
            )

        return self.instance

                def is_valid(self, raise_exception=False):
        assertnot hasattr(self, ‘restore_object‘), (
            ‘Serializer `%s.%s` has old-style version 2 `.restore_object()` ‘‘that is no longer compatible with REST framework 3. ‘‘Use the new-style `.create()` and `.update()` methods instead.‘ %
            (self.__class__.__module__, self.__class__.__name__)
        )

        assert hasattr(self, ‘initial_data‘), (
            ‘Cannot call `.is_valid()` as no `data=` keyword argument was ‘‘passed when instantiating the serializer instance.‘
        )

        ifnot hasattr(self, ‘_validated_data‘):
            try:
                self._validated_data = self.run_validation(self.initial_data)
            except ValidationError as exc:
                self._validated_data = {}
                self._errors = exc.detail
            else:
                self._errors = {}

        if self._errors and raise_exception:
            raise ValidationError(self.errors)

        returnnot bool(self._errors)

                    @property
    
                def
                 data(self):
        
                if hasattr(self, ‘initial_data‘) andnot hasattr(self, ‘_validated_data‘):
            msg = (
                ‘When a serializer is passed a `data` keyword argument you ‘‘must call `.is_valid()` before attempting to access the ‘‘serialized `.data` representation.\n‘‘You should either call `.is_valid()` first, ‘‘or access `.initial_data` instead.‘
            )
            raise AssertionError(msg)

        ifnot hasattr(self, ‘_data‘):
            if self.instance isnot None andnot getattr(self, ‘_errors‘, None):
                self._data = self.to_representation(self.instance)
            elif hasattr(self, ‘_validated_data‘) andnot getattr(self, ‘_errors‘, None):
                self._data = self.to_representation(self.validated_data)
            else:
                self._data = self.get_initial()
        return self._data