[Django]-Circular dependency in Django Rest Framework serializers

Separating usual and nested serializers does the trick for me.

For your structure it will be something like:

Profiles app

# profiles/serializers/common.py

from images.serializers.nested import SimplifiedImageSerializer

class ProfileSerializer(SimplifiedProfileSerializer):
    recent_images = SimplifiedImageSerializer(many=True)

And nested:

# profiles/serializers/nested.py

class SimplifiedProfileSerializer(serializers.Serializer):
    name = serializers.CharField()

Images app

# images/serializers/common.py

from profiles.serializers.nested import SimplifiedProfileSerializer

class ImageSerializer(SimplifiedImageSerializer):
    profile = SimplifiedProfileSerializer()

And nested:

# images/serializers/nested.py

class SimplifiedImageSerializer(serializers.Serializer):
    title = serializers.CharField()

you can do a local import of serializers like this:

class MySerializer(Serializer):
    from app.core.serializers import AnotherSerializer

Do that in both of your imports. No need to use sys.modules

That is, as mentioned by Sebastian Wozny, that you don’t have a logical circular dependancy

You should consider having a look at Specifying nested serialization in the Rest Framework documentation. The usage of depth meta attribute enables you to retrieve related objects to the depth you set.

It is very convenient to avoid using serializers in both sides and thus having ImportError caused by cycles.

The default ModelSerializer uses primary keys for relationships, but you can also easily generate nested representations using the depth option:

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

I just created this utility class to handle circular import problem:

from django.utils.module_loading import import_string
from django.utils.functional import cached_property
from rest_framework.serializers import RelatedField


class DynamicRelatedField(RelatedField):
    def __init__(self, serializer_path=None, **kwargs):
        assert serializer_path is not None, 'The `serializer_path` argument is required.'
        assert kwargs['read_only'], 'Only readonly fields are supported for DynamicRelatedField'
        self.serializer_path = serializer_path
        super().__init__(**kwargs)

    @cached_property
    def serializer_object(self):
        serializer_class = import_string(self.serializer_path)
        return serializer_class()

    def to_representation(self, obj):
        return self.serializer_object.to_representation(obj)

    def to_internal_value(self, data):
        return None

And then, I can use it like the following:

class ProfessorDetailsSerializer(serializers.ModelSerializer):
    courses = DynamicRelatedField('courses.serializers.CourseDetailsSerializer', many=True, read_only=True)

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

Notes

• I used cached_property to prevent serializer_object creation on each instance when using many=True.
• This snippet doesn’t support writable fields, but adding this feature won’t take much work

I’d take a different approach as you do have coupling one way or another.
I’d go with defining the serializer I actually use within the application itself.

Profile application:

# profiles/serializers.py

class SimplifiedImageSerializer(serializers.Serializer):
    title = serializers.CharField()

class ProfileSerializer(SimplifiedProfileSerializer):
    recent_images = SimplifiedImageSerializer(many=True)

Image application:

# images/serializers.py

class SimplifiedProfileSerializer(serializers.Serializer):
    name = serializers.CharField()

class ImageSerializer(SimplifiedImageSerializer):
    profile = SimplifiedProfileSerializer()

I have suffered a lot with Django Serializers Circular Dependency issue and found only two ways to solve it.

1. Arranging my code in a way so that I don’t have to face circular dependency (which was not possible in my case)
2. Creating separate serializer class with the serializer I need and using this new serializer where I needed. This one may not be the most efficient one but this solved my issue.