python - route - django rest framework response

django-rest-framework+Django-polimorphic ModelSerialization

Question

Me preguntaba si alguien tenía una solución Pythonic de combinar el framework Django REST con django-polimórfico.

Dado:

class GalleryItem(PolymorphicModel):
gallery_item_field = models.CharField()
class Photo(GalleryItem):
custom_photo_field = models.CharField()
class Video(GalleryItem):
custom_image_field = models.CharField()

Si quiero una lista de todos los GalleryItems en django-rest-framework, solo me daría los campos de GalleryItem (el modelo principal), por lo tanto: id, gallery_item_field y polymorphic_ctype. Eso no es lo que quiero. Quiero el custom_photo_field si es una instancia de Photo y custom_image_field si es un Video.

Answer 1

Aquí hay una solución general y reutilizable. Es para un Serializer genérico, pero no sería difícil modificarlo para usar ModelSerializer . Tampoco maneja la serialización de la clase padre (en mi caso, uso la clase padre más como una interfaz).

from typing import Dict
from rest_framework import serializers
class PolymorphicSerializer(serializers.Serializer):
"""
Serializer to handle multiple subclasses of another class
- For serialized dict representations, a ''type'' key with the class name as
the value is expected: ex. {''type'': ''Decimal'', ... }
- This type information is used in tandem with get_serializer_map(...) to
manage serializers for multiple subclasses
"""
def get_serializer_map(self) -> Dict[str, serializers.Serializer]:
"""
Return a dict to map class names to their respective serializer classes
To be implemented by all PolymorphicSerializer subclasses
"""
raise NotImplementedError
def to_representation(self, obj):
"""
Translate object to internal data representation
Override to allow polymorphism
"""
type_str = obj.__class__.__name__
try:
serializer = self.get_serializer_map()[type_str]
except KeyError:
raise ValueError(
''Serializer for "{}" does not exist''.format(type_str),
)
data = serializer(obj, context=self.context).to_representation(obj)
data[''type''] = type_str
return data
def to_internal_value(self, data):
"""
Validate data and initialize primitive types
Override to allow polymorphism
"""
try:
type_str = data[''type'']
except KeyError:
raise serializers.ValidationError({
''type'': ''This field is required'',
})
try:
serializer = self.get_serializer_map()[type_str]
except KeyError:
raise serializers.ValidationError({
''type'': ''Serializer for "{}" does not exist''.format(type_str),
})
validated_data = serializer(context=self.context) /
.to_internal_value(data)
validated_data[''type''] = type_str
return validated_data
def create(self, validated_data):
"""
Translate validated data representation to object
Override to allow polymorphism
"""
serializer = self.get_serializer_map()[validated_data[''type'']]
return serializer(context=self.context).create(validated_data)

Y para usarlo:

class ParentClassSerializer(PolymorphicSerializer):
"""
Serializer for ParentClass objects
"""
def get_serializer_map(self) -> Dict[str, serializers.Serializer]:
"""
Return serializer map
"""
return {
ChildClass1.__name__: ChildClass1Serializer,
ChildClass2.__name__: ChildClass2Serializer,
}

Answer 2

Hasta ahora solo he probado esto para una solicitud GET, y esto funciona:

class PhotoSerializer(serializers.ModelSerializer):
class Meta:
model = models.Photo
class VideoSerializer(serializers.ModelSerializer):
class Meta:
model = models.Video
class GalleryItemModuleSerializer(serializers.ModelSerializer):
class Meta:
model = models.GalleryItem
def to_representation(self, obj):
"""
Because GalleryItem is Polymorphic
"""
if isinstance(obj, models.Photo):
return PhotoSerializer(obj, context=self.context).to_representation(obj)
elif isinstance(obj, models.Video):
return VideoSerializer(obj, context=self.context).to_representation(obj)
return super(GalleryItemModuleSerializer, self).to_representation(obj)

Para las solicitudes POST y PUT, es posible que desee hacer algo similar al anular la definición de to_representation con la definición de to_internal_value.

Answer 3

Para completar, estoy agregando la implementación to_internal_value() , ya que necesitaba esto en mi proyecto reciente.

Cómo determinar el tipo

Es útil tener la posibilidad de distinguir entre diferentes "clases"; Así que he agregado la propiedad de tipo en el modelo polimórfico base para este propósito:

class GalleryItem(PolymorphicModel):
gallery_item_field = models.CharField()
@property
def type(self):
return self.__class__.__name__

Esto permite llamar al type como "campo" y "campo de solo lectura".

type contendrá el nombre de la clase python.

Añadiendo tipo al serializador

Puede agregar el type en "campos" y "campos de solo lectura" (debe especificar el campo de tipo en todos los serializadores, si desea usarlos en todos los modelos secundarios)

class PhotoSerializer(serializers.ModelSerializer):
class Meta:
model = models.Photo
fields = ( ..., ''type'', )
read_only_fields = ( ..., ''type'', )
class VideoSerializer(serializers.ModelSerializer):
class Meta:
model = models.Video
fields = ( ..., ''type'', )
read_only_fields = ( ..., ''type'', )
class GalleryItemModuleSerializer(serializers.ModelSerializer):
class Meta:
model = models.GalleryItem
fields = ( ..., ''type'', )
read_only_fields = ( ..., ''type'', )
def to_representation(self, obj):
pass # see the other comment
def to_internal_value(self, data):
"""
Because GalleryItem is Polymorphic
"""
if data.get(''type'') == "Photo":
self.Meta.model = models.Photo
return PhotoSerializer(context=self.context).to_internal_value(data)
elif data.get(''type'') == "Video":
self.Meta.model = models.Video
return VideoSerializer(context=self.context).to_internal_value(data)
self.Meta.model = models.GalleryItem
return super(GalleryItemModuleSerializer, self).to_internal_value(data)