Django Rest Framework - deserialization of a TaggableManager field

Ok, I managed to make it work.

Leaving here the solution for others:

The reson I was getting TypeError: Task() got an unexpected keyword argument 'get_tags' is because drf was trying to use the return value of to_internal_value() to fill in the 'get_tags' field of my model.

Now, 'get_tags' is just method name of my model Task class, not a real field, hence the error. Drf learned about 'get_tags' as a field name when I used tags = TagsField(source="get_tags") in my serializer.

I worked around this issue overriding the create() method of my serializer, in this way:

class TaskSerializer(serializers.ModelSerializer):

    # tags field in Task model is implemented via TaggableManager class from django-taggit.
    # By default, drf is not able to serialize TaggableManager to json.
    # get_tags() is a method of the Task model class, which returns a Queryset containing
    # the list of tags as strings. This Queryset can be serialized without issues.
    tags = TagsField(source="get_tags")
    # variables = VariableSerializer()

    def create(self, validated_data):
        # using "source=get_tags" drf "thinks" get_tags is a real field name, so the
        # return value of to_internal_value() is used a the value of a key called "get_tags" inside validated_data dict. We need to remove it and handle the tags manually.
        tags = validated_data.pop("get_tags")
        task = Task.objects.create(**validated_data)
        task.tags.add(*tags)

        return task

    class Meta:
        model = Task
        # we exclude all those fields we simply receive from Socialminer
        # whenever we get a task or its status
        fields = [
                "name",
                 ...
                "tags",
            ]

I think you may need some sort of tag serializer setup.

So in your TaskSerializer I would have: tags = TagSerializer(many=True, read_only=False)

from serializers import (
    TagListSerializerField,
    TagSerializer
)

class TaskSerializer(TagSerializer, serializers.ModelSerializer):

    # tags field in Task model is implemented via TaggableManager class from django-taggit.
    # By default, drf is not able to serialize TaggableManager to json.
    # get_tags() is a method of the Task model class, which returns a Queryset containing
    # the list of tags as strings. This Queryset can be serialized without issues.
    tags = TagListSerializerField()

    class Meta:
        model = Task
        fields = [
                "name",
                ...,
                "tags",
            ]

I implemented this before many years ago, the TagList, TagListSerializerField and TagSerializer you want is this:

import six
import json

from django.utils.translation import ugettext_lazy as _

from rest_framework import serializer

class TagList(list):
    def __init__(self, *args, **kwargs):
        pretty_print = kwargs.pop("pretty_print", True)
        list.__init__(self, *args, **kwargs)
        self.pretty_print = pretty_print

    def __add__(self, rhs):
        return TagList(list.__add__(self, rhs))

    def __getitem__(self, item):
        result = list.__getitem__(self, item)
        try:
            return TagList(result)
        except TypeError:
            return result

    def __str__(self):
        if self.pretty_print:
            return json.dumps(
                self, sort_keys=True, indent=4, separators=(',', ': '))
        else:
            return json.dumps(self)


class TagListSerializerField(serializers.Field):
    child = serializers.CharField()
    default_error_messages = {
        'not_a_list': _(
            'Expected a list of items but got type "{input_type}".'),
        'invalid_json': _('Invalid json list. A tag list submitted in string'
                          ' form must be valid json.'),
        'not_a_str': _('All list items must be of string type.')
    }
    order_by = None

    def __init__(self, **kwargs):
        pretty_print = kwargs.pop("pretty_print", True)

        style = kwargs.pop("style", {})
        kwargs["style"] = {'base_template': 'textarea.html'}
        kwargs["style"].update(style)

        super(TagListSerializerField, self).__init__(**kwargs)

        self.pretty_print = pretty_print

    def to_internal_value(self, value):
        if isinstance(value, six.string_types):
            value = value.split(',')

        if not isinstance(value, list):
            self.fail('not_a_list', input_type=type(value).__name__)

        for s in value:
            if not isinstance(s, six.string_types):
                self.fail('not_a_str')

            self.child.run_validation(s)
        return value

    def to_representation(self, value):
        if not isinstance(value, TagList):
            if not isinstance(value, list):
                if self.order_by:
                    tags = value.all().order_by(*self.order_by)
                else:
                    tags = value.all()
                value = [tag.name for tag in tags]
            value = TagList(value, pretty_print=self.pretty_print)

        return value


class TagSerializer(serializers.Serializer):
    def create(self, validated_data):
        to_be_tagged, validated_data = self._pop_tags(validated_data)

        tag_object = super(TaggitSerializer, self).create(validated_data)

        return self._save_tags(tag_object, to_be_tagged)

    def update(self, instance, validated_data):
        to_be_tagged, validated_data = self._pop_tags(validated_data)

        tag_object = super(TaggitSerializer, self).update(
            instance, validated_data)

        return self._save_tags(tag_object, to_be_tagged)

    def _save_tags(self, tag_object, tags):
        for key in tags.keys():
            tag_values = tags.get(key)
            getattr(tag_object, key).set(*tag_values)

        return tag_object

    def _pop_tags(self, validated_data):
        to_be_tagged = {}

        for key in self.fields.keys():
            field = self.fields[key]
            if isinstance(field, TagListSerializerField):
                if key in validated_data:
                    to_be_tagged[key] = validated_data.pop(key)

        return (to_be_tagged, validated_data)