我们从Python开源项目中,提取了以下42个代码示例,用于说明如何使用rest_framework.serializers.ModelSerializer()。
def setUp(self): from .models import User depends = self._getTarget() class ForDependsTestUserSerializer(serializers.ModelSerializer): class Meta: model = User fields = ('id', 'first_name', "last_name") first_name = serializers.SerializerMethodField() last_name = serializers.SerializerMethodField() @depends("username") def get_first_name(self, ob): return ob.username.split(" ", 1)[0] @depends("username") def get_last_name(self, ob): return ob.username.split(" ", 1)[1] self.Serializer = ForDependsTestUserSerializer
def _get_name(self): """ :return: Serializer name :rtype: str """ serializer = self.serializer if inspect.isclass(serializer): name = serializer.__name__ else: name = serializer.__class__.__name__ if name == 'DefaultSerializer' and issubclass(serializer, ModelSerializer): model_name = self.serializer.Meta.model.__name__ name = '{0}Serializer'.format(model_name.strip()) return name
def test_override(self): from biohub.utils.rest.serializers import bind_model, get_by_model from rest_framework.serializers import ModelSerializer from tests.utils.rest.models import TestModel @bind_model(TestModel, can_override=True) class SerializerA(ModelSerializer): class Meta: model = TestModel @bind_model(TestModel) class SerializerB(ModelSerializer): class Meta: model = TestModel self.assertIs(get_by_model(TestModel), SerializerB)
def test_bind(self): from biohub.utils.rest.serializers import bind_model, get_by_model from rest_framework.serializers import ModelSerializer from tests.utils.rest.models import TestModel @bind_model(TestModel) class TestModelSerializer(ModelSerializer): class Meta: model = TestModel self.assertIs( get_by_model(TestModel), TestModelSerializer ) with self.assertRaises(KeyError) as cm: @bind_model(TestModel) class AnotherTestSerializer(ModelSerializer): class Meta: model = TestModel self.assertIn('bound', str(cm.exception))
def get_serializer_class(configuration_model): """ Returns a ConfigurationModel serializer class for the supplied configuration_model. """ class AutoConfigModelSerializer(ModelSerializer): """Serializer class for configuration models.""" class Meta(object): """Meta information for AutoConfigModelSerializer.""" model = configuration_model fields = '__all__' def create(self, validated_data): if "changed_by_username" in self.context: validated_data['changed_by'] = User.objects.get(username=self.context["changed_by_username"]) return super(AutoConfigModelSerializer, self).create(validated_data) return AutoConfigModelSerializer
def setUp(self): from .models import User, Skill class AnotherSkillSerializer(serializers.ModelSerializer): fullname = serializers.CharField(source="name") class Meta: model = Skill fields = ("id", "fullname") class AnotherUserSerializer(serializers.ModelSerializer): fullname = serializers.CharField(source="username") my_skills = AnotherSkillSerializer(many=True, source="skills") class Meta: model = User fields = ("id", "fullname", "my_skills") self.Serializer = AnotherUserSerializer
def setUp(self): from .models import User contextual = self._getTarget() def has_xxx_context(xxx, replaced): def check(token, context): return replaced if xxx in context else [] return check class ForContextualTestUserSerializer(serializers.ModelSerializer): class Meta: model = User fields = ('id', 'username') username = serializers.SerializerMethodField() @contextual(has_xxx_context('with_username', 'username')) def get_username(self, ob): return ob.username.split(" ", 1)[0] self.Serializer = ForContextualTestUserSerializer
def __init__(self, *args, **kwargs): serializers.ModelSerializer.__init__(self, *args, **kwargs) queryset = models.PersonEmail.objects.all() try: pk = self.context['view'].kwargs['pk'] except KeyError: pk = None if pk is not None: try: queryset = queryset.exclude(person__id=pk) except ValueError: queryset = queryset.exclude(person__nb_id=pk) self.fields['address'] = serializers.EmailField( max_length=254, validators=[UniqueValidator(queryset=queryset)])
def test_modelserializer_charfield(self): class ArtistSerializer(serializers.ModelSerializer): id = HashidSerializerCharField(source_field='tests.Artist.id') class Meta: model = Artist fields = ('id', 'name') artist = Artist.objects.create(id=128, name="Test Artist") orig_id = artist.id s = ArtistSerializer(artist) self.assertEqual(Artist._meta.get_field('id').salt, s.fields['id'].hashid_salt) self.assertTrue(isinstance(s.data['id'], six.string_types)) self.assertEqual(artist.id.hashid, s.data['id']) s2 = ArtistSerializer(artist, data={'id': 128, 'name': "Test Artist Changed"}) self.assertTrue(s2.is_valid()) artist = s2.save() self.assertEqual(artist.id, orig_id) self.assertEqual(artist.name, "Test Artist Changed")
def test_modelserializer_integerfield(self): class ArtistSerializer(serializers.ModelSerializer): id = HashidSerializerIntegerField(source_field=Artist._meta.get_field('id')) class Meta: model = Artist fields = ('id', 'name') artist = Artist.objects.create(id=256, name="Test Artist") orig_id = artist.id s = ArtistSerializer(artist) self.assertTrue(isinstance(s.data['id'], int)) self.assertEqual(artist.id.id, s.data['id']) s2 = ArtistSerializer(artist, data={'id': 256, 'name': "Test Artist Changed"}) self.assertTrue(s2.is_valid()) artist = s2.save() self.assertEqual(artist.id, orig_id) self.assertEqual(artist.name, "Test Artist Changed")
def create(self, validated_data): account = Account(email=validated_data['email'], first_name=validated_data['first_name'], last_name=validated_data['last_name']) account.set_password(validated_data['password']) # matrix = MatrixApi() # account.matrix_token = matrix.register(validated_data['username'], validated_data['password'])['access_token'] # account.matrix_id = account.save() return account # class GroupSerializers(serializers.ModelSerializer): # class Meta: # model = Group # fields = ('group_type', 'members', 'classroom', 'creator')
def build_serializer(self, cls, model_name): """ Dynamically build a model serializer class """ class_name = "%sSerializer" % model_name meta_class = type('Meta', (), {'model': cls, 'fields': '__all__'}) serializer_args = {'Meta': meta_class} if hasattr(cls, 'content_type'): serializer_args.update({ 'content_type': serializers.StringRelatedField() }) model_serializer = type(class_name, (serializers.ModelSerializer,), serializer_args) return model_serializer
def create(self, validated_data): return serializers.ModelSerializer.create(self, validated_data)
def update(self, instance, validated_data): return serializers.ModelSerializer.update(self, instance, validated_data)
def to_representation(self, instance): ''' This method is overridden to remove blank fields from serialized output. We could put this into a subclassed ModelSerializer if we want it to apply to all our Serializers. :param instance: :return: ''' rep = super().to_representation(instance) return {key: val for key, val in rep.items() if val}
def get_validators(self): """ Hack to remove DRF's UniqueTogetherValidator when it concerns the UUID. See https://github.com/deis/deis/pull/2898#discussion_r23105147 """ validators = super(ModelSerializer, self).get_validators() for v in validators: if isinstance(v, UniqueTogetherValidator) and 'uuid' in v.fields: validators.remove(v) return validators
def validate(self, attrs): email_or_username = attrs.get('email_or_username') password = attrs.get('password') if email_or_username and password: # Check if user sent email if validateEmail(email_or_username): user_request = get_object_or_404( User, email=email_or_username, ) email_or_username = user_request.username user = authenticate(username=email_or_username, password=password) if user: if not user.is_active: msg = _('User account is disabled.') raise ValidationError(msg) else: msg = _('Unable to log in with provided credentials.') raise ValidationError(msg) else: msg = _('Must include "email or username" and "password"') raise ValidationError(msg) attrs['user'] = user return attrs # class ProfileSerializer(serializers.ModelSerializer): # # class Meta: # model = UserProfile # exclude = ('user', 'id', 'organization') #
def get_profile_picture(self, obj): try: if obj.user_profile.profile_picture: return obj.user_profile.profile_picture.url except: return None return None # class ProfileUserSerializer(serializers.ModelSerializer): # # class Meta: # model = User # exclude = ('last_login', 'is_superuser', 'is_staff', 'is_active', 'date_joined', 'groups', 'user_permissions','password') # read_only_fields = ('username', 'email', 'last_login', 'date_joined', 'id')
def convert_serializer_field(field, is_input=True): """ Converts a django rest frameworks field to a graphql field and marks the field as required if we are creating an input type and the field itself is required """ graphql_type = get_graphene_type_from_serializer_field(field) args = [] kwargs = { 'description': field.help_text, 'required': is_input and field.required, } # if it is a tuple or a list it means that we are returning # the graphql type and the child type if isinstance(graphql_type, (list, tuple)): kwargs['of_type'] = graphql_type[1] graphql_type = graphql_type[0] if isinstance(field, serializers.ModelSerializer): if is_input: graphql_type = convert_serializer_to_input_type(field.__class__) else: global_registry = get_global_registry() field_model = field.Meta.model args = [global_registry.get_type_for_model(field_model)] return graphql_type(*args, **kwargs)
def test_should_model_convert_field(): class MyModelSerializer(serializers.ModelSerializer): class Meta: model = None fields = '__all__' assert_conversion(MyModelSerializer, graphene.Field, is_input=False)
def setUp(self): Group.objects.bulk_create([Group(name=name) for name in ['group1', 'group2', 'group3']]) class GroupSerializer(ModelSerializer): class Meta: model = Group fields = '__all__' class GroupViewSet(ModelViewSet): queryset = Group.objects.all() serializer_class = GroupSerializer permission_classes = [DjangoObjectPermissions] filter_backends = [ChemoPermissionsFilter] self.user = User.objects.create_user(username='testuser', password='test123.') self.perm = Permission.objects.create(content_type=get_content_type(Group), name='Can view group', codename='view_group') self.access_rule = AccessRule.objects.create(ctype_source=get_content_type(User), ctype_target=get_content_type(Group), is_active=True, relation_types=[{'GROUPS': None}]) self.view = GroupViewSet self.patched_settings = modify_settings( AUTHENTICATION_BACKENDS={'append': self.backend} ) self.patched_settings.enable()
def find_for_model(model, app_label=None, serializers_module='serializers'): """ This is extends the serializer_registry.find_for_model by searching installed the app provided by either the app_label arg or the model._meta.app_label property, and the serializers_module arg it will loop through any classes found in this module and check for a Meta.model property matching the provided model and return if found. i.e. it will return the first modelserializer it finds matching provided model in the app.module provided, if non found raises ValueError """ from clubhouse.core.options import serializer_registry, NotRegistered try: return serializer_registry.find_for_model(model) except NotRegistered: pass # In the event the serializer is not registered, return the first # serializer found in the app provided by app_label.serializer_module model = ensure_model(model) app_label = app_label if app_label else model._meta.app_label module_name = '%s.%s' % (app_label,serializers_module) try: members = sys.modules[module_name] except KeyError: from importlib import import_module import_module(module_name) members = sys.modules[module_name] for name, obj in inspect.getmembers(members,inspect.isclass): try: if issubclass(obj, serializers.ModelSerializer)\ and obj.Meta.model is model: return obj except AttributeError: # Probably abstract continue raise ValueError('Could not find serializer for model: %s' % model)
def init_serializer(cls): if not hasattr(cls, 'serializer_class') or cls.serializer_class is None: if getattr(cls, 'primary_model', None) is None: cls.serializer_class = Serializer else: field_names = [] for field in cls.primary_model._meta.get_fields(): if field.many_to_one or isinstance(field, ( django.db.models.fields.related.OneToOneField, django.db.models.fields.related.ManyToManyField)): field_name = getattr(field, 'name') elif not field.is_relation: field_name = getattr(field, 'attname') else: continue if field_name not in (SETTINGS.MODEL_CREATOR, SETTINGS.MODEL_MODIFIER): field_names.append(field_name) class BenchmarkSerializer(ModelSerializer): class Meta: model = cls.primary_model fields = field_names cls.serializer_class = BenchmarkSerializer cls.serializer_is_custom = False else: cls.serializer_is_custom = True
def modelserializer_factory(model, serializer=None, fields=None, exclude=None): """ Returns a ModelSerializer containing fields for the given model. :param model: model class. :param fields: is an optional list of field names. If provided, only the named fields will be included in the returned fields. If omitted or '__all__', all fields will be used. :param exclude: is an optional list of field names. If provided, the named fields will be excluded from the returned fields, even if they are listed in the ``fields`` argument. :return: ModelSerializer class """ # default values serializer = serializer or serializers.ModelSerializer attrs = {'model': model} if fields == '__all__': opts = model._meta.concrete_model._meta attrs['fields'] = [field.name for field in opts.fields if field.serialize] elif fields is not None: attrs['fields'] = fields if exclude is not None: attrs['exclude'] = exclude # create meta class parent = (object,) Meta = type('Meta', parent, attrs) # Give this new serializer class a reasonable name. class_name = model.__name__ + 'Serializer' # Class attributes for the new serializer class. serializer_class_attrs = { 'Meta': Meta, } return type(serializer)(class_name, (serializer,), serializer_class_attrs)
def update(self, instance, validated_data): """Update. :param instance: :param validated_data: :return: """ # Collect information on nested serializers __nested_serializers, __nested_serializers_data = \ extract_nested_serializers( self, validated_data, ) # Update the instance instance = super(ModelSerializer, self).update( instance, validated_data ) # Assign fields to the `instance` one by one set_instance_values( __nested_serializers, __nested_serializers_data, instance ) # Save the instance and return instance.save() return instance
def test_fields_value_is___all__(self): from .models import User class SlugUserSerializer(serializers.ModelSerializer): class Meta: model = User fields = '__all__' actual = self._callFUT(SlugUserSerializer) expected = ['id', 'password', 'last_login', 'is_superuser', 'username', 'first_name', 'last_name', 'email', 'is_staff', 'is_active', 'date_joined', 'groups__id', 'user_permissions__id'] self.assertEqual(actual, expected)
def setUp(self): from django.contrib.auth.models import Permission, Group from .models import User, Skill # in django.contrib.auth.models # permission *-* group, permission *-* user, permission *-* groups # in my tests.models: # skill *- user class ContribPermissionSerializer(serializers.ModelSerializer): class Meta: model = Permission fields = "__all__" class SkillSerializer(serializers.ModelSerializer): class Meta: model = Skill fields = "__all__" class UserSerializer(serializers.ModelSerializer): skills = SkillSerializer(many=True) permissions = ContribPermissionSerializer(many=True) class Meta: model = User fields = "__all__" class ContribGroupSerializer(serializers.ModelSerializer): permissions = ContribPermissionSerializer(many=True) users = UserSerializer(many=True) class Meta: model = Group fields = "__all__" self.PermissionSerializer = ContribPermissionSerializer self.SkillSerializer = SkillSerializer self.UserSerializer = UserSerializer self.GroupSerializer = ContribGroupSerializer
def to_representation(self, obj): if isinstance(obj,UserProfile): return super(UserProfileSerializer,self).to_representation(obj) serializer = TokenSerializer(obj) return serializer.data # class ScoreSerializer(serializers.ModelSerializer): # UserId = serializers.IntegerField(source='GiverPersonId_id',read_only=True) #Read olurken hangi user in verdigini anlamak icin kullanilir # Score = serializers.IntegerField(source='Point') # Name = serializers.CharField(source='GiverPersonId.user.first_name',read_only=True) # Image = serializers.ImageField(source='GiverPersonId.Photo', max_length=None, use_url=True, read_only=True) # class Meta(object): # model = Score # fields = ('Score','UserId','Name','Image') # def create(self, validated_data): # taker = self.context['view'].kwargs['pk'] # score = Score.objects.create(TakerPersonId_id=taker ,GiverPersonId_id=self.context['request'].user.id, **validated_data) # scores = Score.objects.filter(TakerPersonId_id=taker) # total = 0.0 # for score in scores: # total += score.Point # avarage_score = total / len(scores) # user = UserProfile.objects.get(pk=taker) # user.Score = avarage_score # user.save() # return {'IsSuccess':True,'context':''} # def to_representation(self, obj): # if isinstance(obj,Score): # return super(ScoreSerializer,self).to_representation(obj) # serializer = ResultSerializer(obj) # return serializer.data
def test_default_modelserializer_field(self): class ArtistSerializer(serializers.ModelSerializer): class Meta: model = Artist fields = ('id', 'name') with self.assertRaises(exceptions.ImproperlyConfigured): ArtistSerializer().fields() # Fields aren't built until first accessed
def get_serializer_class(self): if self.serializer_class is None: class AutoConfigModelSerializer(ModelSerializer): """Serializer class for configuration models.""" class Meta(object): """Meta information for AutoConfigModelSerializer.""" model = self.model self.serializer_class = AutoConfigModelSerializer return self.serializer_class
def get_raw_type_from_serializer_field(field): if isinstance(field, ListSerializer): return 'list' if isinstance(field, ModelSerializer): return 'model' # return smart_text(field.Meta.model.__name__).lower() name = field.__class__.__name__ if name.endswith('Field'): name = smart_text(name[:-5]) return smart_text(name).lower()
def _build_serializer(self, serializer_class, fields=None, instance=None): if serializer_class is None: return None kwargs = {} if hasattr(self, 'initial_data'): # Route initial data to the corresponding child serializer, e.g. # model data --> ModelSerializer. initial_data = self.initial_data or {} data = {k: v for k, v in initial_data.iteritems() if k in fields} kwargs['data'] = data return serializer_class( context=self._context, partial=self.partial, instance=instance, **kwargs)
def generate_model_serializer(name, model, model_fields, bases=None): """ Generates a `ModelSerializer` given the model_fields. The specified `model_fields` is a tuple of model fields properties and the already created drf_fields. The former are passed to the `Meta` class of serializer in order to be created afterwards, whereas the latter are specified directly to the serializer class. """ field_properties, drf_fields = classify_model_fields( model_fields) if not (field_properties or drf_fields): return None drf_fields = drf_fields or {} meta_cls_content = { 'model': model, 'fields': drf_fields.keys() + field_properties.keys(), 'extra_kwargs': field_properties, } cls_content = { field_name: serializer for field_name, serializer in drf_fields.iteritems() } custom_bases = map(utils.LOAD_CLASS, bases or []) base_cls = tuple(custom_bases) + (ApimasModelSerializer,) meta_cls = type('Meta', (object,), meta_cls_content) cls_content['Meta'] = meta_cls return type(name, base_cls, cls_content)
def _extract_field_info(self, model, field_name, field, fields, relationships, adapter, target_app, allow_recursion=False): if field_name == 'id': return None field_item = { 'name': field_name, 'type': adapter.field_type_mapping[field.__class__.__name__] } if isinstance(field, PrimaryKeyRelatedField) or isinstance(field, ManyRelatedField) \ or isinstance(field, ModelSerializer): if model is None: field_item['related_model'] = field.queryset.model._meta.model_name.lower() field_item['app'] = target_app if target_app is not None else \ field.queryset.model._meta.app_label.lower() relationships.append(field_item) else: model_field = model._meta.get_field(field_name) field_item['related_model'] = model_field.related_model._meta.model_name.lower() field_item['app'] = target_app if target_app is not None else \ model_field.related_model._meta.app_label.lower() relationships.append(field_item) if hasattr(model_field, 'field'): field_item['inverse'] = model_field.field.name elif hasattr(model_field, 'remote_field') and \ getattr(model_field.remote_field, 'related_name', None) is not None: field_item['inverse'] = model_field.remote_field.related_name if field_item.get('inverse', '-')[-1] == '+': field_item.pop('inverse') if isinstance(field, ModelSerializer): if hasattr(field, 'many') and field.many: field_item['type'] = adapter.field_type_mapping['ManyRelatedField'] else: field_item['type'] = adapter.field_type_mapping['PrimaryKeyRelatedField'] elif isinstance(field, ModelSerializer): field_item['related_model'] = field.queryset.model._meta.model_name.lower() field_item['app'] = target_app if target_app is not None else \ field.queryset.model._meta.app_label.lower() relationships.append(field_item) if field.many: field_item['type'] = adapter.field_type_mapping['ManyRelatedField'] else: field_item['type'] = adapter.field_type_mapping['PrimaryKeyRelatedField'] elif isinstance(field, ListSerializer): child_rels = [] child_fields = [] self._extract_field_info(model, field_name, field.child, child_fields, child_rels, adapter, target_app) if len(child_rels) > 0: for item in child_rels: item['type'] = adapter.field_type_mapping['ManyRelatedField'] item.pop('inverse', None) relationships.append(item) else: field_item['type'] = adapter.field_type_mapping('ListField') fields.append(field_item) else: fields.append(field_item) return field_item
def update(self, instance, validated_data): reverse_relations = OrderedDict() relations = OrderedDict() # Sort fields by create priority fields = self.get_sorted_by_create_priority(self.fields) # Remove related fields from validated data for future manipulations for field_name, field in fields.items(): if field.read_only: continue if isinstance(field, serializers.ListSerializer): if isinstance(field.child, serializers.ModelSerializer): if validated_data.pop(field.source, None) is None: # Skip field if field is not required or null allowed continue reverse_relations[field_name] = field.child if isinstance(field, serializers.ModelSerializer): if validated_data.pop(field.source, None) is None: # Skip field if field is not required or null allowed continue relations[field_name] = field nested_related_kwarg = getattr(self.Meta, 'nested_related_kwarg', None) if reverse_relations: assert nested_related_kwarg, \ "Set `nested_related_kwarg` in Meta options for use nested " \ "create feature" if relations: raise NotImplementedError("NestedUpdateMixin not provide update " "for direct relations") # Update instance instance = super(NestedUpdateMixin, self).update( instance, validated_data) if reverse_relations: self.update_reverse_relations(instance, reverse_relations) self.delete_reverse_relations_if_need(instance, reverse_relations) return instance
def create(self, validated_data): reverse_relations = OrderedDict() relations = OrderedDict() # Sort fields by create priority fields = self.get_sorted_by_create_priority(self.fields) # Remove related fields from validated data for future manipulations for field_name, field in fields.items(): if field.read_only or field_name in self._ignore_creation: continue if isinstance(field, serializers.ListSerializer): if isinstance(field.child, serializers.ModelSerializer): if validated_data.pop(field.source, None) is None: # Skip field if field is not required or null allowed continue reverse_relations[field_name] = field.child if isinstance(field, serializers.ModelSerializer): if validated_data.pop(field.source, None) is None: # Skip field if field is not required or null allowed continue relations[field_name] = field nested_related_kwarg = getattr(self.Meta, 'nested_related_kwarg', None) if reverse_relations: assert nested_related_kwarg, \ "Set `nested_related_kwarg` in Meta options for use nested " \ "create feature" # Create direct relations (foreign key) for field_name, field in relations.items(): serializer = self._get_new_serializer( field, data=self.initial_data[field_name]) serializer.is_valid(raise_exception=True) validated_data[field.source] = serializer.save() # Create instance instance = super(NestedCreateMixin, self).create(validated_data) if reverse_relations: self.create_reverse_relations(instance, reverse_relations) return instance
def modelserializer_factory(model, serializer=serializers.ModelSerializer, fields=None, exclude=None, **kwargs): """ Generate serializer basing on django's modelform_factory :param model: model we create serializer for :param serializer: base serializer class :param fields: list of fields to include in serializer :param exclude: list of fields to exclude from serializer :param kwargs: fields mapping :return: """ # TODO: decide if we need cache and what to do with parameters tha can be different serializer_class = serializer_cache.get(model, None) if serializer_class: return serializer_class def _get_declared_fields(attrs): fields = [(field_name, attrs.pop(field_name)) for field_name, obj in list(attrs.items()) if isinstance(obj, serializers.Field)] fields.sort(key=lambda x: x[1]._creation_counter) return OrderedDict(fields) meta_attrs = {'model': model} if fields is not None: meta_attrs['fields'] = fields if exclude is not None: meta_attrs['exclude'] = exclude if fields is None and exclude is None: meta_attrs['fields'] = '__all__' parent = (object, ) Meta = type(str('Meta'), parent, meta_attrs) class_name = model.__name__ + str('Serializer') serializer_class_attrs = { 'Meta': Meta, '_get_declared_fields': _get_declared_fields(kwargs), } serializer_class = type(serializer)(class_name, (serializer,), serializer_class_attrs) serializer_cache[model] = serializer_class return serializer_class
def _validate_configuration(self): meta_cls = getattr(self, 'Meta', None) if meta_cls is None: raise ex.ApimasException('`Meta` class cannot be found') model_fields = getattr(meta_cls, 'model_fields', []) fields = getattr(meta_cls, 'extra_fields', []) if not (fields or model_fields): raise ex.ApimasException( '`extra_fields` and `model_fields` attributes are not' ' specified') if not (self.model_ser_cls or self.ser_cls): raise ex.ApimasException( 'A `ContainerSerializer` must define a `ModelSerializer` class' ' or a `Serializer class') if not (self.model_ser_cls or self.ser_cls): raise ex.ApimasException( 'A `ContainerSerializer` must include a ModelSerializer' ' and Serializer class') if self.model_ser_cls: mro = inspect.getmro(self.model_ser_cls) if serializers.HyperlinkedModelSerializer not in mro: raise ex.ApimasException( 'A model serializer class must inherit' ' `serializers.ModelSerializer`') if self.ser_cls: mro = inspect.getmro(self.ser_cls) if serializers.BaseSerializer not in mro: raise ex.ApimasException( 'A serializer class must implement' ' `serializers.BaseSerializer`') return model_fields, fields