Reuse existing Django rest framework serializer - django

Question

I am currently using Django Rest Framework and I am looking for a way to reuse some attributes from an already defined Serializer. In order to explain, I am going to expose some of the serializers involved:
Completed Serializer:
class ProductSerializer(serializers.ModelSerializer):
subscribed = serializers.SerializerMethodField()
other_field = serializers.SerializerMethodField()
class Meta:
model = Product
fields = [
'id',
'name',
'subscribed',
'other_field',
'x',
'y',
'z'
]
def get_subscribed(self, product: Product):
return product.is_user_subscribed(self.context['request'].user)
Simplified Serializer:
class ProductSimplifiedSerializer(serializers.ModelSerializer):
subscribed = serializers.SerializerMethodField()
class Meta:
model = Product
fields = [
'id',
'name',
'subscribed'
]
def get_subscribed(self, product: Product):
return product.is_user_subscribed(self.context['request'].user)
As you can notice above, those serializers are almost the same, but one of them is a simplified version of the object because I don't want to retrieve unnecessary information in some parts. The problem here is that in this scenario we have a method serializer that will need to be maintained two times. Maybe in the future, I would want to add another field, and I will need to add it to both. So, how could be achieved a Based Serializer in which all the fields are included but I could reuse it and extract specific fields from it?
I have already thought these options:
1. Using Base Serializer instance:
Draft:
def to_representation(self, instance)
desired_format = self.context['format']
if desired_format == 'simplified':
fields = ['fields_for_simplified']
elif desired_format == 'regular':
fields = ['fields_for_regular']
for field in fields:
# make the representation
With this approach, I do not know even if it would be a good idea or it is possible
Using SerializerField
Draft:
class UserSubscribed(serializer.SerializerField)
def to_representation(self, instance):
return 'representation'
class ProductSimplifiedSerializer(serializers.ModelSerializer):
user_subscribed = UserSubscribed()
class Meta:
model = Product
fields = [
'id',
'name',
'user_subscribed'
]
I think this last one is better, the problem is that this _user_subscribed_ is not a property of the Product instance and it is failing because of that and I do not know how to achieve this.
What would be your suggestion regarding this situation? Any advice would be appreciated.
Thanks!

Answer 1

You can subclass the simple one and add fields in the full one.
class ProductSimplifiedSerializer(serializers.ModelSerializer):
subscribed = serializers.SerializerMethodField()
class Meta:
model = Product
fields = [
'id',
'name',
'subscribed'
]
def get_subscribed(self, product: Product):
return product.is_user_subscribed(self.context['request'].user)
class ProductSerializer(ProductSimplifiedSerializer):
other_field = serializers.SerializerMethodField()
class Meta(ProductSimplifiedSerializer.Meta):
fields = ProductSimplifiedSerializer.Meta.fields + [
'other_field',
'x',
'y',
'z'
]
The trick here is that you can subclass the Meta class too. Any attributes you define in the Meta subclass will overwrite the parent ones, so you gotta manually use the parent ones.

Answer 2

You can create mixin for serializer class which would let you specify which fields will be "used" in serializer, any else will be ignored.
class DynamicFieldsMixin(object):
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().__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)
Then you can use your serializer like this:
class ProductSerializer(DynamicFieldsMixin, serializers.ModelSerializer)
serializer = ProductSerializer(fields=("id", "name", "subscribed"))