Python 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 __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 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