def _get_response_for_code(self, serializer): serializer = force_instance(serializer) if not serializer: return {'description': _('No response body')} elif isinstance(serializer, serializers.ListSerializer): if is_serializer(serializer.child): schema = self.resolve_serializer(serializer.child, 'response').ref else: schema = self._map_serializer_field(serializer.child, 'response') elif is_serializer(serializer): component = self.resolve_serializer(serializer, 'response') if not component.schema: return {'description': _('No response body')} schema = component.ref elif is_basic_type(serializer): schema = build_basic_type(serializer) elif isinstance(serializer, dict): # bypass processing and use given schema directly schema = serializer else: warn( f'could not resolve "{serializer}" for {self.method} {self.path}. Expected either ' f'a serializer or some supported override mechanism. defaulting to ' f'generic free-form object.') schema = build_basic_type(OpenApiTypes.OBJECT) schema['description'] = _('Unspecified response body') if self._is_list_view(serializer) and not get_override( serializer, 'many') is False: schema = build_array_type(schema) paginator = self._get_paginator() if paginator and is_serializer(serializer): paginated_name = f'Paginated{self._get_serializer_name(serializer, "response")}List' component = ResolvedComponent( name=paginated_name, type=ResolvedComponent.SCHEMA, schema=paginator.get_paginated_response_schema(schema), object=paginated_name, ) self.registry.register(component) schema = component.ref elif paginator: schema = paginator.get_paginated_response_schema(schema) return { 'content': { mt: { 'schema': schema } for mt in self.map_renderers('media_type') }, # Description is required by spec, but descriptions for each response code don't really # fit into our model. Description is therefore put into the higher level slots. # https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.3.md#responseObject 'description': '' }
def _map_response_type_hint(self, method): hint = get_override(method, 'field') or typing.get_type_hints(method).get('return') if is_serializer(hint) or is_field(hint): return self._map_serializer_field(force_instance(hint), 'response') elif is_basic_type(hint): return build_basic_type(hint) elif getattr(hint, '__origin__', None) is typing.Union: if type(None) == hint.__args__[1] and len(hint.__args__) == 2: schema = build_basic_type(hint.__args__[0]) schema['nullable'] = True return schema else: warn(f'type hint {hint} not supported yet. defaulting to "string"') return build_basic_type(OpenApiTypes.STR) else: warn(f'type hint for function "{method.__name__}" is unknown. defaulting to string.') return build_basic_type(OpenApiTypes.STR)
def _map_basic_serializer(self, serializer, direction): serializer = force_instance(serializer) required = set() properties = {} for field in serializer.fields.values(): if isinstance(field, serializers.HiddenField): continue if field.field_name in get_override(serializer, 'exclude_fields', []): continue schema = self._map_serializer_field(field, direction) # skip field if there is no schema for the direction if not schema: continue add_to_required = ( field.required or (schema.get('readOnly') and not spectacular_settings.COMPONENT_NO_READ_ONLY_REQUIRED)) if add_to_required: required.add(field.field_name) self._map_field_validators(field, schema) properties[field.field_name] = safe_ref(schema) if spectacular_settings.COMPONENT_SPLIT_PATCH: if self.method == 'PATCH' and direction == 'request': required = [] return build_object_type( properties=properties, required=required, description=get_doc(serializer.__class__), )
def _map_serializer_field(self, field, direction): if has_override(field, 'field'): override = get_override(field, 'field') if is_basic_type(override): return build_basic_type(override) else: return self._map_serializer_field(override, direction) meta = self._get_serializer_field_meta(field) serializer_field_extension = OpenApiSerializerFieldExtension.get_match( field) if serializer_field_extension: schema = serializer_field_extension.map_serializer_field( self, direction) return append_meta(schema, meta) # nested serializer if isinstance(field, serializers.Serializer): component = self.resolve_serializer(field, direction) return append_meta(component.ref, meta) if component else None # nested serializer with many=True gets automatically replaced with ListSerializer if isinstance(field, serializers.ListSerializer): if is_serializer(field.child): component = self.resolve_serializer(field.child, direction) return append_meta(build_array_type(component.ref), meta) if component else None else: schema = self._map_serializer_field(field.child, direction) return append_meta(build_array_type(schema), meta) # Related fields. if isinstance(field, serializers.ManyRelatedField): schema = self._map_serializer_field(field.child_relation, direction) # remove hand-over initkwargs applying only to outer scope schema.pop('description', None) schema.pop('readOnly', None) return append_meta(build_array_type(schema), meta) if isinstance(field, serializers.PrimaryKeyRelatedField): # read_only fields do not have a Manager by design. go around and get field # from parent. also avoid calling Manager. __bool__ as it might be customized # to hit the database. if getattr(field, 'queryset', None) is not None: model_field = field.queryset.model._meta.pk else: if isinstance(field.parent, serializers.ManyRelatedField): model_field = field.parent.parent.Meta.model._meta.pk else: model_field = field.parent.Meta.model._meta.pk # primary keys are usually non-editable (readOnly=True) and map_model_field correctly # signals that attribute. however this does not apply in the context of relations. schema = self._map_model_field(model_field, direction) schema.pop('readOnly', None) return append_meta(schema, meta) if isinstance(field, serializers.StringRelatedField): return append_meta(build_basic_type(OpenApiTypes.STR), meta) if isinstance(field, serializers.SlugRelatedField): return append_meta(build_basic_type(OpenApiTypes.STR), meta) if isinstance(field, serializers.HyperlinkedIdentityField): return append_meta(build_basic_type(OpenApiTypes.URI), meta) if isinstance(field, serializers.HyperlinkedRelatedField): return append_meta(build_basic_type(OpenApiTypes.URI), meta) if isinstance(field, serializers.MultipleChoiceField): return append_meta( build_array_type(build_choice_field(field.choices)), meta) if isinstance(field, serializers.ChoiceField): return append_meta(build_choice_field(field.choices), meta) if isinstance(field, serializers.ListField): schema = build_array_type({}) # TODO check this if not isinstance(field.child, _UnvalidatedField): map_field = self._map_serializer_field(field.child, direction) items = {"type": map_field.get('type')} if 'format' in map_field: items['format'] = map_field.get('format') schema['items'] = items return append_meta(schema, meta) # DateField and DateTimeField type is string if isinstance(field, serializers.DateField): return append_meta(build_basic_type(OpenApiTypes.DATE), meta) if isinstance(field, serializers.DateTimeField): return append_meta(build_basic_type(OpenApiTypes.DATETIME), meta) if isinstance(field, serializers.TimeField): return append_meta(build_basic_type(OpenApiTypes.TIME), meta) if isinstance(field, serializers.EmailField): return append_meta(build_basic_type(OpenApiTypes.EMAIL), meta) if isinstance(field, serializers.URLField): return append_meta(build_basic_type(OpenApiTypes.URI), meta) if isinstance(field, serializers.UUIDField): return append_meta(build_basic_type(OpenApiTypes.UUID), meta) if isinstance(field, serializers.DurationField): return append_meta(build_basic_type(OpenApiTypes.STR), meta) if isinstance(field, serializers.IPAddressField): # TODO this might be a DRF bug. protocol is not propagated to serializer although it # should have been. results in always 'both' (thus no format) if 'ipv4' == field.protocol.lower(): schema = build_basic_type(OpenApiTypes.IP4) elif 'ipv6' == field.protocol.lower(): schema = build_basic_type(OpenApiTypes.IP6) else: schema = build_basic_type(OpenApiTypes.STR) return append_meta(schema, meta) # DecimalField has multipleOf based on decimal_places if isinstance(field, serializers.DecimalField): if getattr(field, 'coerce_to_string', api_settings.COERCE_DECIMAL_TO_STRING): content = { **build_basic_type(OpenApiTypes.STR), 'format': 'decimal' } else: content = build_basic_type(OpenApiTypes.DECIMAL) if field.max_whole_digits: content['maximum'] = int(field.max_whole_digits * '9') + 1 content['minimum'] = -content['maximum'] self._map_min_max(field, content) return append_meta(content, meta) if isinstance(field, serializers.FloatField): content = build_basic_type(OpenApiTypes.FLOAT) self._map_min_max(field, content) return append_meta(content, meta) if isinstance(field, serializers.IntegerField): content = build_basic_type(OpenApiTypes.INT) self._map_min_max(field, content) # 2147483647 is max for int32_size, so we use int64 for format if int(content.get('maximum', 0)) > 2147483647 or int( content.get('minimum', 0)) > 2147483647: content['format'] = 'int64' return append_meta(content, meta) if isinstance(field, serializers.FileField): if spectacular_settings.COMPONENT_SPLIT_REQUEST and direction == 'request': content = build_basic_type(OpenApiTypes.BINARY) else: use_url = getattr(field, 'use_url', api_settings.UPLOADED_FILES_USE_URL) content = build_basic_type( OpenApiTypes.URI if use_url else OpenApiTypes.STR) return append_meta(content, meta) if isinstance(field, serializers.SerializerMethodField): method = getattr(field.parent, field.method_name) return append_meta(self._map_response_type_hint(method), meta) if anyisinstance( field, [serializers.BooleanField, serializers.NullBooleanField]): return append_meta(build_basic_type(OpenApiTypes.BOOL), meta) if isinstance(field, serializers.JSONField): return append_meta(build_basic_type(OpenApiTypes.OBJECT), meta) if anyisinstance(field, [serializers.DictField, serializers.HStoreField]): content = build_basic_type(OpenApiTypes.OBJECT) if not isinstance(field.child, _UnvalidatedField): content['additionalProperties'] = self._map_serializer_field( field.child, direction) return append_meta(content, meta) if isinstance(field, serializers.CharField): return append_meta(build_basic_type(OpenApiTypes.STR), meta) if isinstance(field, serializers.ReadOnlyField): # direct source from the serializer assert field.source_attrs, f'ReadOnlyField "{field}" needs a proper source' target = follow_field_source(field.parent.Meta.model, field.source_attrs) if callable(target): schema = self._map_response_type_hint(target) elif isinstance(target, models.Field): schema = self._map_model_field(target, direction) else: assert False, f'ReadOnlyField target "{field}" must be property or model field' return append_meta(schema, meta) # DRF was not able to match the model field to an explicit SerializerField and therefore # used its generic fallback serializer field that simply wraps the model field. if isinstance(field, serializers.ModelField): schema = self._map_model_field(field.model_field, direction) return append_meta(schema, meta) warn( f'could not resolve serializer field "{field}". defaulting to "string"' ) return append_meta(build_basic_type(OpenApiTypes.STR), meta)