我们从Python开源项目中,提取了以下40个代码示例,用于说明如何使用rest_framework.serializers.Serializer()。
def test_char_field_error_content(self): # Too long string self.data_set['title'] = 'Too Long Title For Defined Serializer' s = run_is_valid(SnippetSerializer, data=self.data_set) code = settings.FRIENDLY_FIELD_ERRORS['CharField']['max_length'] self.assertEqual(s.errors['errors'][0]['code'], code) self.assertEqual(s.errors['errors'][0]['field'], 'title') # Empty string self.data_set['title'] = '' s = run_is_valid(SnippetSerializer, data=self.data_set) code = settings.FRIENDLY_FIELD_ERRORS['CharField']['blank'] self.assertEqual(s.errors['errors'][0]['code'], code) self.assertEqual(s.errors['errors'][0]['field'], 'title') # No data provided self.data_set.pop('title') s = run_is_valid(SnippetSerializer, data=self.data_set) code = settings.FRIENDLY_FIELD_ERRORS['CharField']['required'] self.assertEqual(s.errors['errors'][0]['code'], code) self.assertEqual(s.errors['errors'][0]['field'], 'title')
def _get_default_field_kwargs(property_class): """ Return default kwargs used to initialize the Serializer field with. :param property_class: Neomodel property class """ defaults = property_class.__dict__.copy() delete_attrs = [ 'db_property', 'choices', 'has_default', 'index', 'unique_index' ] for attr in delete_attrs: if attr in defaults: del defaults[attr] return defaults
def get_paginator_serializer(self, view, child_serializer_class): class BaseFakeListSerializer(serializers.Serializer): results = child_serializer_class(many=True) class FakePrevNextListSerializer(BaseFakeListSerializer): next = URLField() previous = URLField() # Validate if the view has a pagination_class if not (hasattr(view, 'pagination_class')) or view.pagination_class is None: return BaseFakeListSerializer pager = view.pagination_class if hasattr(pager, 'default_pager'): # Must be a ProxyPagination pager = pager.default_pager if issubclass(pager, (PageNumberPagination, LimitOffsetPagination)): class FakeListSerializer(FakePrevNextListSerializer): count = IntegerField() return FakeListSerializer elif issubclass(pager, CursorPagination): return FakePrevNextListSerializer return BaseFakeListSerializer
def __init__(self, oftype = None, model = None, fields = ['__all__']): assert oftype is not None, ('You should specify a type for the serializer') assert type(fields) is list, ('Serializer fields should be listed') assert len(fields) > 0, ('Serializer fields should not be an empty list') self.fields = fields self.oftype = oftype self.model = model self.serializer = LazyClass('SwaggerDefaultSerializer', self.oftype) self.serializer.set_attr('Meta', self.make_meta())
def get_NAME_serializer(self, field: models.Field, qs: models.QuerySet, obj=None) -> Serializer: """ Returns serializer <NAME> field. This method (`get_NAME_serializer`) is not supposed to use directly. :param obj: optional obj passed to method :param field: model field :param qs: queryset :return: Serializer """ raise Exception() # noinspection PyPep8Naming,PyMethodMayBeStatic
def get_serializer_fields(self, path, method, view): """ Return a list of `coreapi.Field` instances corresponding to any request body input, as determined by the serializer class. """ if method not in ('PUT', 'PATCH', 'POST'): return [] if not hasattr(view, 'get_serializer'): return [] serializer = view.get_serializer() if isinstance(serializer, serializers.ListSerializer): return [ coreapi.Field( name='data', location='body', required=True, schema=coreschema.Array() ) ] if not isinstance(serializer, serializers.Serializer): return [] fields = [] for field in serializer.fields.values(): if field.read_only or isinstance(field, serializers.HiddenField): continue required = field.required and method != 'PATCH' field = coreapi.Field( name=field.field_name, location='form', required=required, schema=field_to_schema(field) ) fields.append(field) return fields
def __init__(self, data=None, status=None, template_name=None, headers=None, exception=False, content_type=None): """ Alters the init arguments slightly. For example, drop 'template_name', and instead use 'data'. Setting 'renderer' and 'media_type' will typically be deferred, For example being set automatically by the `APIView`. """ super(Response, self).__init__(None, status=status) if isinstance(data, Serializer): msg = ( 'You passed a Serializer instance as data, but ' 'probably meant to pass serialized `.data` or ' '`.error`. representation.' ) raise AssertionError(msg) self.data = data self.template_name = template_name self.exception = exception self.content_type = content_type if headers: for name, value in six.iteritems(headers): self[name] = value
def add_disponibility_representation(func): @wraps(func) def _impl(self, instance): # We pop disponibility field to avoid AttributeError on default Serializer.to_representation for i, field in enumerate(self._readable_fields): if field.field_name == "disponibility": disponibility = self._readable_fields.pop(i) ret = func(self, instance) self._readable_fields.insert(i, disponibility) # Put disp back # Add disponibility representation obj = None ret["disponibility"] = None try: type = "job" obj = JobSerializer().to_representation(instance.job) except models.Job.DoesNotExist: try: type = "work" obj = WorkSerializer().to_representation(instance.work) except models.Work.DoesNotExist: # pragma: no cover pass if obj: ret["disponibility"] = { "type": type, type: obj } return ret return _impl
def __init__(self, field, parent, only_fields, include_fields): self.field = field self.parent = parent self.is_many = isinstance(field, serializers.ListSerializer) and isinstance(field.child, serializers.Serializer) self.has_context = isinstance(field, serializers.Serializer) or self.is_many if self.has_context: self.old_context = None self.only_fields = self.filter_fields(field.field_name, only_fields) self.include_fields = self.filter_fields(field.field_name, include_fields) self.on_exit_delete_fields = False self.on_exit_delete_include_fields = False self.old_fields = None self.old_include_fields = None
def data(self): return super(serializers.Serializer, self).data
def paginated_response(queryset, serializer_class, request): """ Pagination helper for a @detail route. http://stackoverflow.com/a/29144786/1377500 :type serializer_class: rest_framework.serializers.Serializer :rtype: rest_framework.response.Response """ paginator = CountedPageNumberPagination() page = paginator.paginate_queryset(queryset, request) serializer = serializer_class( page, many=True, context={'request': request}) return paginator.get_paginated_response(serializer.data)
def setUp(self): class TestSerializer(serializers.Serializer): ctype = ContentTypeIdentityField(queryset=ContentType.objects.all()) self.Serializer = TestSerializer self.ctype = ContentType.objects.get(app_label='auth', model='user')
def test_serialize_valid_input(self): serializer = self.Serializer(data={'ctype': 'auth.user'}) self.assertTrue(serializer.is_valid()) self.assertEqual(serializer.validated_data['ctype'], self.ctype)
def test_serialize_invalid_data_type(self): serializer = self.Serializer(data={'ctype': 1}) self.assertFalse(serializer.is_valid()) self.assertTrue('ctype' in serializer.errors) try: serializer.is_valid(raise_exception=True) self.fail('Did not raise ValidationError when serializing invalid data type using `raise_exception=True`') except serializers.ValidationError as e: self.assertEqual( str(e), "{'ctype': ['Incorrect type. Expected content type string identifier, received int.']}")
def test_serialize_invalid_length_content_type_string(self): serializer = self.Serializer(data={'ctype': 'auth'}) self.assertFalse(serializer.is_valid()) self.assertTrue('ctype' in serializer.errors) try: serializer.is_valid(raise_exception=True) self.fail('Did not raise ValidationError when serializing invalid content ' 'type string using `raise_exception=True`') except serializers.ValidationError as e: self.assertEqual(str(e), "{'ctype': ['Incorrect length. Expected content type string, " "separated by punctuation. Received \"auth\".']}")
def test_serializer_non_existent_content_type(self): serializer = self.Serializer(data={'ctype': 'non.existent'}) self.assertFalse(serializer.is_valid()) self.assertTrue('ctype' in serializer.errors) try: serializer.is_valid(raise_exception=True) self.fail('Did not raise exception when serializing non-existent content ' 'type string using using `raise_exception=True`') except serializers.ValidationError as e: self.assertEqual(str(e), "{'ctype': ['Invalid content type \"non.existent\" - object does not exist.']}")
def test_serialize_valid_permission_input(self): serializer = self.Serializer(data={'perm': self.perm_string}) self.assertTrue(serializer.is_valid()) self.assertEqual(serializer.validated_data['perm'], self.permission)
def test_serialize_invalid_permission_data_type(self): serializer = self.Serializer(data={'perm': 1}) self.assertFalse(serializer.is_valid()) self.assertTrue('perm' in serializer.errors) try: serializer.is_valid(raise_exception=True) self.fail('Did not raise ValidationError when serializing invalid data type using `raise_exception=True`') except serializers.ValidationError as e: self.assertEqual( str(e), "{'perm': ['Incorrect type. Expected permission string identifier, received int.']}")
def test_serialize_invalid_length_permission_string(self): serializer = self.Serializer(data={'perm': 'add_user'}) self.assertFalse(serializer.is_valid()) self.assertTrue('perm' in serializer.errors) try: serializer.is_valid(raise_exception=True) self.fail('Did not raise ValidationError when serializing invalid permission ' 'string using `raise_exception=True`') except serializers.ValidationError as e: self.assertEqual(str(e), "{'perm': ['Incorrect length. Expected permission string identifier, " "separated by punctuation. Received \"add_user\".']}")
def test_serializer_non_existent_permission(self): serializer = self.Serializer(data={'perm': 'auth.can_levitate'}) self.assertFalse(serializer.is_valid()) self.assertTrue('perm' in serializer.errors) try: serializer.is_valid(raise_exception=True) self.fail('Did not raise exception when serializing non-existent permission ' 'string using using `raise_exception=True`') except serializers.ValidationError as e: self.assertEqual(str(e), "{'perm': ['Invalid permission \"auth.can_levitate\" " "- object does not exist.']}")
def get_serializer_class(self): if self.action == 'review': return serializers.Serializer return super().get_serializer_class()
def build_nested_field(self, field_name, info, relationship, nested_depth): """ Builds nested serializer to handle relationshipped model """ target_model = relationship.mapper.class_ nested_fields = self.get_nested_relationship_fields(target_model, info, relationship, nested_depth) field_kwargs = self.get_relationship_kwargs(relationship, nested_depth) field_kwargs = self.include_extra_kwargs(field_kwargs, self._extra_kwargs.get(field_name)) nested_extra_kwargs = {} nested_info = model_info(target_model) if not field_kwargs.get('required', True): for nested_field in nested_info.primary_keys: nested_extra_kwargs.setdefault(nested_field, {}).setdefault('required', False) if not field_kwargs.get('allow_nested_updates', True): nested_depth = 0 for nested_field in nested_info.properties: nested_extra_kwargs.setdefault(nested_field, {}).setdefault('read_only', True) nested_extra_kwargs.setdefault(nested_field, {}).pop('required', None) class NestedSerializer(ModelSerializer): class Meta: model = target_model session = self.session depth = max(0, nested_depth - 1) fields = nested_fields extra_kwargs = nested_extra_kwargs return type(target_model.__name__ + 'Serializer', (NestedSerializer, ), {})(**field_kwargs)
def _makeSerializer(self): class CommentSerializer(serializers.Serializer): name = serializers.CharField() content = serializers.CharField() class ArticleSerializer(serializers.Serializer): name = serializers.CharField() content = serializers.CharField() comments = CommentSerializer(many=True) return ArticleSerializer
def test_it(self): Serializer = self._makeOne(self._makeSerializer()) article = self._makeArticle() result = Serializer(article).data expected = '{"name": "hello", "content": "hello world", "comments": [{"name": "title0", "content": "hmm"}, {"name": "title1", "content": "hmm"}, {"name": "title2", "content": "hmm"}]}' # NOQA actual = json.dumps(result) self.assertEqual(actual, expected)
def test_it__filtering(self): Serializer = self._makeOne(self._makeSerializer()) article = self._makeArticle() request = self._makeDummyRequest({"skip_fields": "content,comments__content"}) result = Serializer(article, context={"request": request}).data expected = '{"name": "hello", "comments": [{"name": "title0"}, {"name": "title1"}, {"name": "title2"}]}' # NOQA actual = json.dumps(result) self.assertEqual(actual, expected)
def test_it__filtering__from_list__cached(self): Serializer = self._makeOne(self._makeSerializer()) articles = [self._makeArticle(), self._makeArticle(), self._makeArticle()] request = self._makeDummyRequest({"skip_fields": "content,comments__content"}) result = Serializer(articles, context={"request": request}, many=True).data expected = '[{"name": "hello", "comments": [{"name": "title0"}, {"name": "title1"}, {"name": "title2"}]}, {"name": "hello", "comments": [{"name": "title0"}, {"name": "title1"}, {"name": "title2"}]}, {"name": "hello", "comments": [{"name": "title0"}, {"name": "title1"}, {"name": "title2"}]}]' # NOQA actual = json.dumps(result) self.assertEqual(actual, expected)
def __init__(self, allow_extra): class Model(serializers.Serializer): id = serializers.IntegerField() client_name = serializers.CharField(max_length=255) sort_index = serializers.FloatField() # client_email = serializers.EmailField(required=False, allow_null=True) client_phone = serializers.CharField(max_length=255, required=False, allow_null=True) class Location(serializers.Serializer): latitude = serializers.FloatField(required=False, allow_null=True) longitude = serializers.FloatField(required=False, allow_null=True) location = Location(required=False, allow_null=True) contractor = serializers.IntegerField(required=False, allow_null=True, min_value=0) upstream_http_referrer = serializers.CharField(max_length=1023, required=False, allow_null=True) grecaptcha_response = serializers.CharField(min_length=20, max_length=1000) last_updated = serializers.DateTimeField(required=False, allow_null=True) class Skill(serializers.Serializer): subject = serializers.CharField() subject_id = serializers.IntegerField() category = serializers.CharField() qual_level = serializers.CharField() qual_level_id = serializers.IntegerField() qual_level_ranking = serializers.FloatField(default=0) skills = serializers.ListField(child=Skill()) self.allow_extra = allow_extra # unused self.serializer = Model
def __init__(self, data=None, status=None, template_name=None, headers=None, exception=False, content_type=None, err_code=0, err_msg=''): """ Alters the init arguments slightly. For example, drop 'template_name', and instead use 'data'. Setting 'renderer' and 'media_type' will typically be deferred, For example being set automatically by the `APIView`. """ super(Response, self).__init__(None, status=status) if isinstance(data, Serializer): msg = ( 'You passed a Serializer instance as data, but ' 'probably meant to pass serialized `.data` or ' '`.error`. representation.' ) raise AssertionError(msg) self.data = data self.template_name = template_name self.exception = exception self.content_type = content_type self.wrapper = { 'code': err_code, 'message': err_msg, 'data': self.data } if headers: for name, value in six.iteritems(headers): self[name] = value
def get_serializers(self): """ Get `Serializer`classes for every collection. """ return self.serializers
def get_serializer(self, endpoint, collection): """ Get `Serializer` class based on the given collection. """ return self.get_class(self.serializers, endpoint, collection)
def generate_serializer(self, field_schema, name, model=None, onmodel=False, model_serializers=None, extra_serializers=None): """ Generate a `Serializer` class to serve the given `field_schema`. There are two scenarios: * If `field_schema` only consists of model fields and `onmodel` flag is specified as True, then a `ModelSerializer` class is generated. * If `field_schema` consists of non-model fields or a mixture of model fields and non-model fields, then a `ContainerSerializer` class is created. """ model_fields, extra_fields, sources = self._classify_fields( field_schema) if onmodel: assert model, ('You cannot create a model serializer without' ' specifying its model') serializer = generate_model_serializer( name, model, model_fields, bases=model_serializers) else: serializer = generate_container_serializer( model_fields, extra_fields, name, model, instance_sources=sources, model_serializers=model_serializers, extra_serializers=extra_serializers) return serializer
def construct_drf_collection(self, instance, spec, loc, context): """ Constructor for `.drf_collection` predicate. It generates the required, `Serializer` class, and `ViewSet` class based on the field schema, actions, permissions and additional configuation (filter_fields, mixins) as specified on spec. """ endpoint = loc[0] parent = context.get('parent_name') constructed = context.get('constructed') if '.collection' not in constructed: raise doc.DeferConstructor field_schema = doc.doc_get(instance, ('*',)) actions = doc.doc_get(instance, ('.actions', self.ADAPTER_CONF)) or [] model = self._get_or_import_model(loc[0] + '/' + parent, loc + ('model',), context.get('top_spec')) model_serializers = spec.pop('model_serializers', []) extra_serializers = spec.pop('serializers', []) serializer = self.generate_serializer( field_schema, parent, model=model, model_serializers=model_serializers, extra_serializers=extra_serializers) kwargs = {k: v for k, v in spec.iteritems() if k != 'model'} permissions = self.get_permissions(loc[:-1], context.get('top_spec')) view = generate_view(parent, serializer, model, actions=actions, permissions=permissions, **kwargs) instance[self.ADAPTER_CONF] = view self.serializers[endpoint + '/' + parent] = serializer self.views[endpoint + '/' + parent] = view return instance
def generate_nested_drf_field(self, instance, name, predicate_type, model, onmodel=True, **kwargs): """ Generate a nested drf field, which is actually a `Serializer` class. """ kwargs.update(self.get_default_properties(predicate_type, kwargs)) field_schema = doc.doc_get(instance, (predicate_type,)) many = predicate_type == '.structarray' model_serializers = kwargs.pop('model_serializers', []) extra_serializers = kwargs.pop('serializers', []) serializer = self.generate_serializer( field_schema, name, onmodel=onmodel, model_serializers=model_serializers, extra_serializers=extra_serializers, model=model) return serializer(many=many, **kwargs)
def __getitem__(self, key): field = self.fields[key] value = self.data.get(key) error = self.errors.get(key) if hasattr(self, '_errors') else None if isinstance(field, serializers.Serializer): return serializers.NestedBoundField(field, value, error) return serializers.BoundField(field, value, error)
def field_to_schema(field): title = force_text(field.label) if field.label else '' description = force_text(field.help_text) if field.help_text else '' if isinstance(field, serializers.ListSerializer): child_schema = field_to_schema(field.child) return coreschema.Array( items=child_schema, title=title, description=description ) elif isinstance(field, serializers.Serializer): return coreschema.Object( properties=OrderedDict([ (key, field_to_schema(value)) for key, value in field.fields.items() ]), title=title, description=description ) elif isinstance(field, serializers.ManyRelatedField): return coreschema.Array( items=coreschema.String(), title=title, description=description ) elif isinstance(field, serializers.RelatedField): return coreschema.String(title=title, description=description) elif isinstance(field, serializers.MultipleChoiceField): return coreschema.Array( items=coreschema.Enum(enum=list(field.choices.keys())), title=title, description=description ) elif isinstance(field, serializers.ChoiceField): return coreschema.Enum( enum=list(field.choices.keys()), title=title, description=description ) elif isinstance(field, serializers.BooleanField): return coreschema.Boolean(title=title, description=description) elif isinstance(field, (serializers.DecimalField, serializers.FloatField)): return coreschema.Number(title=title, description=description) elif isinstance(field, serializers.IntegerField): return coreschema.Integer(title=title, description=description) if field.style.get('base_template') == 'textarea.html': return coreschema.String( title=title, description=description, format='textarea' ) return coreschema.String(title=title, description=description)
def run_autooptimization_discovery(serializer, prefix, select_related_set, prefetch_related_set, is_prefetch, only_fields, include_fields): if not hasattr(serializer, "Meta") or not hasattr(serializer.Meta, "model"): return model_class = serializer.Meta.model if hasattr(serializer, "get_on_demand_fields"): on_demand_fields = serializer.get_on_demand_fields() else: on_demand_fields = set() def filter_field_name(field_name, fields_to_serialize): if fields_to_serialize is not None: return ContextPassing.filter_fields(field_name, fields_to_serialize) return None for field_name, field in serializer.fields.items(): if hasattr(serializer, "check_if_needs_serialization"): if not serializer.check_if_needs_serialization(field_name, only_fields, include_fields, on_demand_fields): continue if isinstance(field, ListSerializer): if "." not in field.source and hasattr(model_class, field.source): model_field = getattr(model_class, field.source) if check_if_prefetch_object(model_field): prefetch_related_set.add(prefix + field.source) run_autooptimization_discovery(field.child, prefix + field.source + "__", select_related_set, prefetch_related_set, True, filter_field_name(field_name, only_fields), filter_field_name(field_name, include_fields)) elif isinstance(field, Serializer): if "." not in field.source and hasattr(model_class, field.source): model_field = getattr(model_class, field.source) if check_if_related_object(model_field): if is_prefetch: prefetch_related_set.add(prefix + field.source) else: select_related_set.add(prefix + field.source) run_autooptimization_discovery(field, prefix + field.source + "__", select_related_set, prefetch_related_set, is_prefetch, filter_field_name(field_name, only_fields), filter_field_name(field_name, include_fields)) elif "." in field.source: field_name = field.source.split(".", 1)[0] if hasattr(model_class, field_name): model_field = getattr(model_class, field_name) if check_if_related_object(model_field): select_related_set.add(prefix + field_name)
def get_serializer_fields(self, path, method, view, version=None, method_func=None): """ Return a list of `coreapi.Field` instances corresponding to any request body input, as determined by the serializer class. """ if method not in ('PUT', 'PATCH', 'POST'): return [] serializer_class = self.get_serializer_class(view, method_func) if not serializer_class: return [] serializer = serializer_class() if isinstance(serializer, serializers.ListSerializer): return [ Field( name='data', location='body', required=True, schema=coreschema.Array() ) ] if not isinstance(serializer, serializers.Serializer): return [] fields = [] for field in serializer.fields.values(): if field.read_only or isinstance(field, serializers.HiddenField): continue required = field.required and method != 'PATCH' # if the attribute ('help_text') of this field is a lazy translation object, force it to generate a string description = str(field.help_text) if isinstance(field.help_text, Promise) else field.help_text fallback_schema = self.fallback_schema_from_field(field) field = Field( name=field.field_name, location='form', required=required, schema=fallback_schema if fallback_schema else field_to_schema(field), description=description, ) fields.append(field) return fields
def get_response_object(self, response_serializer_class, description): fields = [] serializer = response_serializer_class() nested_obj = {} for field in serializer.fields.values(): # If field is a serializer, attempt to get its schema. if isinstance(field, serializers.Serializer): subfield_schema = self.get_response_object(field.__class__, None)[0].get('schema') # If the schema exists, use it as the nested_obj if subfield_schema is not None: nested_obj[field.field_name] = subfield_schema nested_obj[field.field_name]['description'] = field.help_text continue # Otherwise, carry-on and use the field's schema. fallback_schema = self.fallback_schema_from_field(field) fields.append(Field( name=field.field_name, location='form', required=field.required, schema=fallback_schema if fallback_schema else field_to_schema(field), )) res = _get_parameters(Link(fields=fields), None) if not res: if nested_obj: return { 'description': description, 'schema': { 'type': 'object', 'properties': nested_obj } }, {} else: return {}, {} schema = res[0]['schema'] schema['properties'].update(nested_obj) response_schema = { 'description': description, 'schema': schema } error_status_codes = {} response_meta = getattr(response_serializer_class, 'Meta', None) for status_code, description in getattr(response_meta, 'error_status_codes', {}).items(): error_status_codes[status_code] = {'description': description} return response_schema, error_status_codes
def save(self, **kwargs): ismodel = isinstance(self, ApimasModelSerializer) assert not hasattr(self, 'save_object'), ( 'Serializer `%s.%s` has old-style version 2 `.save_object()` ' 'that is no longer compatible with REST framework 3. ' 'Use the new-style `.create()` and `.update()` methods instead.' % (self.__class__.__module__, self.__class__.__name__) ) assert hasattr(self, '_errors'), ( 'You must call `.is_valid()` before calling `.save()`.' ) assert not self.errors, ( 'You cannot call `.save()` on a serializer with invalid data.' ) # Guard against incorrect use of `serializer.save(commit=False)` assert 'commit' not in kwargs, ( "'commit' is not a valid keyword argument to the 'save()' method. " "If you need to access data before committing to the database then " "inspect 'serializer.validated_data' instead. " "You can also pass additional keyword arguments to 'save()' if you " "need to set extra attributes on the saved model instance. " "For example: 'serializer.save(owner=request.user)'.'" ) assert not hasattr(self, '_data'), ( "You cannot call `.save()` after accessing `serializer.data`." "If you need to access data before committing to the database then " "inspect 'serializer.validated_data' instead. " ) if ismodel: validated_data = dict( list(self.validated_data.items()) + list(kwargs.items()) ) else: validated_data = self.validated_data if self.instance is not None: self.instance = self.update(self.instance, validated_data)\ if ismodel else self.update(self.instance, validated_data, **kwargs) if ismodel: assert self.instance is not None, ( '`update()` did not return an object instance.' ) else: self.instance = self.create(validated_data) if ismodel\ else self.create(validated_data, **kwargs) if ismodel: assert self.instance is not None, ( '`create()` did not return an object instance.' ) return self.instance